factbase 0.14.7 → 0.15.1

data/test/factbase/test_rules.rb

@@ -1,113 +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/rules'
-require_relative '../../lib/factbase/pre'
-
-# Test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestRules < Factbase::Test
-  def test_simple_checking
-    fb = Factbase::Rules.new(
-      Factbase.new,
-      '(when (exists first) (exists second))'
-    )
-    f1 = fb.insert
-    f1.second = 2
-    f1.first = 1
-    f2 = fb.insert
-    assert_raises(StandardError) do
-      f2.first = 1
-    end
-  end
-
-  def test_check_with_id
-    fb = Factbase::Rules.new(Factbase.new, '(exists foo)', uid: 'id')
-    fb.txn do |fbt|
-      f = fbt.insert
-      f.foo = 42
-    end
-  end
-
-  def test_to_string
-    fb = Factbase::Rules.new(
-      Factbase.new,
-      '(when (exists a) (exists b))'
-    )
-    f = fb.insert
-    f.foo = 42
-    s = f.to_s
-    assert_predicate(s.length, :positive?, s)
-    assert_equal('[ foo: [42] ]', s)
-  end
-
-  def test_query_one
-    fb = Factbase::Rules.new(Factbase.new, '(always)')
-    f = fb.insert
-    f.foo = 42
-    assert_equal(1, fb.query('(agg (eq foo $v) (count))').one(Factbase.new, v: 42))
-  end
-
-  def test_check_only_when_txn_is_closed
-    fb = Factbase::Rules.new(Factbase.new, '(when (exists a) (exists b))')
-    ok = false
-    assert_raises(StandardError) do
-      fb.txn do |fbt|
-        f = fbt.insert
-        f.a = 1
-        f.c = 2
-        ok = true
-      end
-    end
-    assert(ok)
-  end
-
-  def test_rollback_on_violation
-    fb = Factbase::Rules.new(Factbase.new, '(when (exists a) (exists b))')
-    assert_raises(StandardError) do
-      fb.txn do |fbt|
-        f = fbt.insert
-        f.a = 1
-        f.c = 2
-      end
-    end
-    assert_equal(0, fb.size)
-  end
-
-  def test_defends_against_id_duplicates
-    fb = Factbase::Rules.new(Factbase.new, '(always)', uid: 'id')
-    assert_raises(StandardError) do
-      fb.txn do |fbt|
-        fbt.insert.then do |f|
-          f.id = 1
-          f.id = 2
-        end
-      end
-    end
-  end
-
-  def test_in_combination_with_pre
-    fb = Factbase::Rules.new(Factbase.new, '(when (exists a) (exists b))')
-    fb =
-      Factbase::Pre.new(fb) do |f|
-        f.hello = 42
-      end
-    ok = false
-    assert_raises(StandardError) do
-      fb.txn do |fbt|
-        f = fbt.insert
-        f.a = 1
-        f.c = 2
-        ok = true
-      end
-    end
-    assert(ok)
-    assert_equal(0, fb.query('(eq hello $v)').each(v: 42).to_a.size)
-  end
-end

data/test/factbase/test_syntax.rb

@@ -1,166 +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/syntax'
-
-# Syntax test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestSyntax < Factbase::Test
-  def test_parses_string_right
-    [
-      "(foo 'abc')",
-      "(foo 'one two')",
-      "(foo 'one two three   ')",
-      "(foo 'one two three   ' 'tail tail')"
-    ].each do |q|
-      assert_equal(q, Factbase::Syntax.new(q).to_term.to_s, q)
-    end
-  end
-
-  def test_makes_abstract_terms
-    {
-      '(foo $bar)' => true,
-      '(foo (bar (a (b c (f $bar)))))' => true,
-      '(foo (bar (a (b c (f bar)))))' => false
-    }.each do |q, a|
-      assert_equal(a, Factbase::Syntax.new(q).to_term.abstract?)
-    end
-  end
-
-  def test_makes_static_terms
-    {
-      '(foo bar)' => false,
-      '(foo "bar")' => true,
-      '(agg (always) (max id))' => true
-    }.each do |q, a|
-      assert_equal(a, Factbase::Syntax.new(q).to_term.static?)
-    end
-  end
-
-  def test_simple_parsing
-    [
-      '(foo)',
-      '(foo (bar) (zz 77)   ) # hey',
-      "# hello\n\n\n(foo ($bar))",
-      "(eq foo   \n\n 'Hello, world!'\n)\n",
-      "(eq x 'Hello, \\' \n) \\' ( world!')",
-      "# this is a comment\n(eq foo # test\n 42)\n\n# another comment\n",
-      "(foo 'Hello,\n\nworld!\r\t\n')\n",
-      "(or ( a 4) (b 5) (always) (and (always) (c 5) \t\t(r 7 w8s w8is 'Foo')))"
-    ].each do |q|
-      refute_nil(Factbase::Syntax.new(q).to_term)
-    end
-  end
-
-  def test_exact_parsing
-    [
-      '(foo)',
-      '(foo 7)',
-      "(foo 7 'Dude')",
-      "(r 'Dude\\'s Friend')",
-      "(r 'I\\'m \\\"good\\\"')",
-      '(foo x y z)',
-      "(foo x y z t f 42 'Hi!# you' 33)",
-      '(foo (x) y z)',
-      '(eq t 2024-05-25T19:43:48Z)',
-      '(eq t 2024-05-25T19:43:48Z)',
-      '(eq t 3.1415926)',
-      '(eq t 3.0e+21)',
-      "(foo (x (f (t (y 42 'Hey you'))) (never) (r 3)) y z)"
-    ].each do |q|
-      assert_equal(q, Factbase::Syntax.new(q).to_term.to_s, q)
-    end
-  end
-
-  def test_simple_matching
-    m = {
-      'foo' => ['Hello, world!'],
-      'bar' => [42],
-      'z' => [1, 2, 3, 4]
-    }
-    {
-      '(eq z 1)' => true,
-      '(or (eq bar 888) (eq z 1))' => true,
-      "(or (gt bar 100) (eq foo 'Hello, world!'))" => true
-    }.each do |k, v|
-      assert_equal(v, Factbase::Syntax.new(k).to_term.evaluate(m, [], Factbase.new), k)
-    end
-  end
-
-  def test_broken_syntax
-    [
-      '',
-      '()',
-      '(foo',
-      '(foo $)',
-      '(foo 1) (bar 2)',
-      'some text',
-      '"hello, world!',
-      '(foo 7',
-      "(foo 7 'Dude'",
-      '(foo x y z (',
-      '(bad-term-name 42)',
-      '(foo x y (z t (f 42 ',
-      ')foo ) y z)',
-      '(x "")',
-      ")y 42 'Hey you)",
-      ')',
-      '"'
-    ].each do |q|
-      msg = assert_raises(q) do
-        Factbase::Syntax.new(q).to_term
-      end.message
-      assert_includes(msg, q, msg)
-    end
-  end
-
-  def test_raises_on_broken_syntax
-    100.times do
-      q = [
-        '(', ')', '#test', '$foo', '%what',
-        '"hello"', '42', '+', '?', '!', '\"',
-        '\'', 'привет'
-      ].shuffle.join(' . ')
-      assert_raises(Factbase::Syntax::Broken, q) do
-        Factbase::Syntax.new(q).to_term
-      end
-    end
-  end
-
-  def test_simplification
-    {
-      '(foo)' => '(foo)',
-      '(and (foo) (foo))' => '(foo)',
-      '(and (foo) (or (and (eq a 1))) (eq a 1) (foo))' => '(and (foo) (eq a 1))'
-    }.each do |s, t|
-      assert_equal(t, Factbase::Syntax.new(s).to_term.to_s)
-    end
-  end
-
-  def test_fails_when_term_is_not_a_class
-    assert_raises(StandardError) { Factbase::Syntax.new('(foo 1)', term: 'hello') }
-  end
-
-  def test_fails_when_term_is_wrong_class
-    assert_raises(StandardError) { Factbase::Syntax.new('(bar 1)', term: String).to_term }
-  end
-
-  def test_fails_when_term_is_incorrectly_defined_class
-    assert_includes(
-      assert_raises(StandardError) { Factbase::Syntax.new('(bar 1)', term: FakeTerm).to_term }.message,
-      'wrong number of arguments'
-    )
-  end
-
-  class FakeTerm < Factbase::Term
-    def initialize(invalid)
-      super
-      @x = invalid
-    end
-  end
-end

data/test/factbase/test_tallied.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../test__helper'
-require 'threads'
-require_relative '../../lib/factbase'
-require_relative '../../lib/factbase/tallied'
-
-# Test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestTallied < Factbase::Test
-  def test_counts_size
-    fb = Factbase::Tallied.new(Factbase.new)
-    assert_equal(0, fb.size)
-  end
-
-  def test_queries_empty_factbase
-    fb = Factbase::Tallied.new(Factbase.new)
-    assert_equal(0, fb.query('(gt foo 1)').each.to_a.size)
-  end
-
-  def test_counts_simple_changes
-    fb = Factbase::Tallied.new(Factbase.new)
-    fb.insert.bar = 3
-    fb.query('(exists bar)').each do |f|
-      f.foo = 42
-    end
-    assert_equal(1, fb.churn.inserted)
-    assert_equal(0, fb.churn.deleted)
-    assert_equal(2, fb.churn.added)
-  end
-
-  def test_counts_in_one
-    fb = Factbase::Tallied.new(Factbase.new)
-    fb.insert.bar = 3
-    assert_equal(1, fb.query('(agg (eq bar 3) (count))').one)
-    assert_equal(1, fb.churn.added)
-  end
-
-  def test_returns_all_props
-    fb = Factbase::Tallied.new(Factbase.new)
-    f = fb.insert
-    f.bar = 3
-    assert_includes(f.all_properties, 'bar')
-  end
-
-  def test_counts_in_txn
-    fb = Factbase::Tallied.new(Factbase.new)
-    fb.txn do |fbt|
-      fbt.insert.boom = 3
-      fbt.query('(exists boom)').each do |f|
-        f.foo = 88
-      end
-    end
-    assert_equal(1, fb.churn.inserted)
-    assert_equal(0, fb.churn.deleted)
-    assert_equal(2, fb.churn.added)
-  end
-
-  def test_counts_in_txn_in_threads
-    fb = Factbase::Tallied.new(Factbase.new)
-    t = 5
-    Threads.new(t).assert do |i|
-      fb.txn do |fbt|
-        fbt.insert.x = i
-        fbt.query("(eq x #{i})").each do |f|
-          f.send(:"a#{i}=", i)
-        end
-        fbt.query("(lt x #{t + 1})").delete!
-      end
-    end
-    assert_equal(0, fb.size)
-    assert_equal(t, fb.churn.inserted)
-    assert_equal(t, fb.churn.deleted)
-    assert_equal(t * 2, fb.churn.added)
-  end
-end

data/test/factbase/test_taped.rb

@@ -1,72 +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/taped'
-
-# Test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestTaped < Factbase::Test
-  def test_tracks_insertion
-    t = Factbase::Taped.new([])
-    t << {}
-    assert_equal(1, t.inserted.size)
-  end
-
-  def test_joins_with_empty
-    t = Factbase::Taped.new([{ foo: 'yes' }])
-    t &= []
-    assert_equal(0, t.size)
-  end
-
-  def test_disjoins_with_empty
-    t = Factbase::Taped.new([{ bar: 'oops' }])
-    t |= []
-    assert_equal(1, t.size)
-  end
-
-  def test_tracks_deletion
-    t = Factbase::Taped.new([{ x: 1 }, { x: 2 }])
-    t.delete_if { |m| m[:x] == 1 }
-    assert_equal(1, t.deleted.size)
-  end
-
-  def test_tracks_addition
-    h = { f: 5 }
-    t = Factbase::Taped.new([h])
-    t.each do |m|
-      m[:bar] = 66
-    end
-    assert_equal(1, t.added.size)
-    assert_equal(h.object_id, t.added.first)
-  end
-
-  def test_tracks_addition_uniquely
-    h = { f: 5 }
-    t = Factbase::Taped.new([h])
-    t.each do |m|
-      m[:bar] = 66
-      m[:foo] = 77
-    end
-    assert_equal(1, t.added.size)
-  end
-
-  def test_tracks_factbase
-    t = Factbase::Taped.new([])
-    fb = Factbase.new(t)
-    fb.insert
-    fb.query('(always)').each do |f|
-      f.foo = 42
-      f.foo = 5
-    end
-    fb.query('(always)').delete!
-    assert_equal(1, t.inserted.size)
-    assert_equal(1, t.added.size)
-    assert_equal(1, t.deleted.size)
-  end
-end

data/test/factbase/test_tee.rb

@@ -1,85 +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/accum'
-require_relative '../../lib/factbase/tee'
-require_relative '../../lib/factbase/fact'
-
-def global_function_for_test_only(foo)
-  raise foo
-end
-
-# Tee test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestTee < Factbase::Test
-  def test_two_facts
-    prim = Factbase::Fact.new({})
-    prim.foo = 42
-    upper = Factbase::Fact.new({})
-    upper.bar = 13
-    t = Factbase::Tee.new(prim, upper)
-    assert_equal(42, t.foo)
-    assert_equal([13], t['$bar'])
-  end
-
-  def test_no_trip_to_prim_if_not_found
-    prim = Factbase::Fact.new({})
-    prim.foo = 777
-    t = Factbase::Tee.new(prim, Factbase::Fact.new({}))
-    assert_nil(t['$foo'])
-  end
-
-  def test_fetches_simply
-    t = Factbase::Accum.new(
-      Factbase::Tee.new(
-        Factbase::Fact.new({ 'foo_bar' => [987] }),
-        Factbase::Fact.new({})
-      ),
-      {}, true
-    )
-    assert_equal(987, t.foo_bar)
-  end
-
-  def test_fetches_without_conflict_with_global_name
-    t = Factbase::Tee.new(
-      Factbase::Fact.new({ 'global_function_for_test_only' => [2] }),
-      Factbase::Fact.new({})
-    )
-    assert_equal(2, t.global_function_for_test_only)
-  end
-
-  def test_all_properties
-    prim = Factbase::Fact.new({})
-    prim.foo = 42
-    upper = Factbase::Fact.new({})
-    upper.bar = 13
-    t = Factbase::Tee.new(prim, upper)
-    assert_includes(t.all_properties, 'foo')
-    assert_includes(t.all_properties, 'bar')
-  end
-
-  def test_recursively
-    map = {}
-    prim = Factbase::Fact.new(map)
-    prim.foo = 42
-    t = Factbase::Tee.new(Factbase::Fact.new({}), { 'bar' => [7] })
-    assert_equal([7], t['$bar'])
-    t = Factbase::Tee.new(prim, t)
-    assert_equal([7], t['$bar'])
-  end
-
-  def test_prints_to_string
-    prim = Factbase::Fact.new({})
-    prim.foo = 42
-    upper = Factbase::Fact.new({})
-    upper.bar = 13
-    t = Factbase::Tee.new(prim, upper)
-    assert_equal('[ foo: [42] ]', t.to_s)
-  end
-end

data/test/factbase/test_term.rb

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

data/test/factbase/test_to_json.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../test__helper'
-require 'loog'
-require_relative '../../lib/factbase'
-require_relative '../../lib/factbase/to_json'
-
-# Test.
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class TestToJSON < Factbase::Test
-  def test_simple_rendering
-    fb = Factbase.new
-    f = fb.insert
-    f.foo = 42
-    f.foo = 256
-    to = Factbase::ToJSON.new(fb)
-    json = JSON.parse(to.json)
-    assert_equal(256, json[0]['foo'][1])
-  end
-
-  def test_sort_keys
-    fb = Factbase.new
-    f = fb.insert
-    f.c = 42
-    f.b = 1
-    f.a = 256
-    json = Factbase::ToJSON.new(fb).json
-    assert_includes(json, '{"a":256,"b":1,"c":42}', json)
-  end
-end