factbase 0.7.5 → 0.9.0

data/test/factbase/test_syntax.rb

@@ -18,7 +18,7 @@ class TestSyntax < Factbase::Test
       "(foo 'one two three   ')",
       "(foo 'one two three   ' 'tail tail')"
     ].each do |q|
-      assert_equal(q, Factbase::Syntax.new(Factbase.new, q).to_term.to_s, q)
+      assert_equal(q, Factbase::Syntax.new(q).to_term.to_s, q)
     end
   end
 
@@ -28,7 +28,7 @@ class TestSyntax < Factbase::Test
       '(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(Factbase.new, q).to_term.abstract?)
+      assert_equal(a, Factbase::Syntax.new(q).to_term.abstract?)
     end
   end
 
@@ -38,7 +38,7 @@ class TestSyntax < Factbase::Test
       '(foo "bar")' => true,
       '(agg (always) (max id))' => true
     }.each do |q, a|
-      assert_equal(a, Factbase::Syntax.new(Factbase.new, q).to_term.static?)
+      assert_equal(a, Factbase::Syntax.new(q).to_term.static?)
     end
   end
 
@@ -53,7 +53,7 @@ class TestSyntax < Factbase::Test
       "(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(Factbase.new, q).to_term)
+      refute_nil(Factbase::Syntax.new(q).to_term)
     end
   end
 
@@ -73,7 +73,7 @@ class TestSyntax < Factbase::Test
       '(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(Factbase.new, q).to_term.to_s, q)
+      assert_equal(q, Factbase::Syntax.new(q).to_term.to_s, q)
     end
   end
 
@@ -88,7 +88,7 @@ class TestSyntax < Factbase::Test
       '(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(Factbase.new, k).to_term.evaluate(m, []), k)
+      assert_equal(v, Factbase::Syntax.new(k).to_term.evaluate(m, [], Factbase.new), k)
     end
   end
 
@@ -113,33 +113,46 @@ class TestSyntax < Factbase::Test
       '"'
     ].each do |q|
       msg = assert_raises(q) do
-        Factbase::Syntax.new(Factbase.new, q).to_term
+        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(Factbase.new, s).to_term.to_s)
+      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(Factbase.new, '(foo 1)', term: 'hello') }
+    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(Factbase.new, '(bar 1)', term: String).to_term }
+    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(Factbase.new, '(bar 1)', term: FakeTerm).to_term }.message,
+      assert_raises(StandardError) { Factbase::Syntax.new('(bar 1)', term: FakeTerm).to_term }.message,
       'wrong number of arguments'
     )
   end

data/test/factbase/test_tee.rb

@@ -14,9 +14,9 @@ require_relative '../../lib/factbase/fact'
 # License:: MIT
 class TestTee < Factbase::Test
   def test_two_facts
-    prim = Factbase::Fact.new(Factbase.new, Mutex.new, {})
+    prim = Factbase::Fact.new({})
     prim.foo = 42
-    upper = Factbase::Fact.new(Factbase.new, Mutex.new, {})
+    upper = Factbase::Fact.new({})
     upper.bar = 13
     t = Factbase::Tee.new(prim, upper)
     assert_equal(42, t.foo)
@@ -24,9 +24,9 @@ class TestTee < Factbase::Test
   end
 
   def test_all_properties
-    prim = Factbase::Fact.new(Factbase.new, Mutex.new, {})
+    prim = Factbase::Fact.new({})
     prim.foo = 42
-    upper = Factbase::Fact.new(Factbase.new, Mutex.new, {})
+    upper = Factbase::Fact.new({})
     upper.bar = 13
     t = Factbase::Tee.new(prim, upper)
     assert_includes(t.all_properties, 'foo')
@@ -35,18 +35,18 @@ class TestTee < Factbase::Test
 
   def test_recursively
     map = {}
-    prim = Factbase::Fact.new(Factbase.new, Mutex.new, map)
+    prim = Factbase::Fact.new(map)
     prim.foo = 42
-    t = Factbase::Tee.new(nil, { 'bar' => 7 })
+    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(Factbase.new, Mutex.new, {})
+    prim = Factbase::Fact.new({})
     prim.foo = 42
-    upper = Factbase::Fact.new(Factbase.new, Mutex.new, {})
+    upper = Factbase::Fact.new({})
     upper.bar = 13
     t = Factbase::Tee.new(prim, upper)
     assert_equal('[ foo: [42] ]', t.to_s)

data/test/factbase/test_term.rb

@@ -4,6 +4,7 @@
 # SPDX-License-Identifier: MIT
 
 require_relative '../test__helper'
+require_relative '../../lib/factbase'
 require_relative '../../lib/factbase/term'
 
 # Term test.
@@ -12,65 +13,73 @@ require_relative '../../lib/factbase/term'
 # License:: MIT
 class TestTerm < Factbase::Test
   def test_false_matching
-    t = Factbase::Term.new(Factbase.new, :never, [])
-    refute(t.evaluate(fact('foo' => [100]), []))
+    t = Factbase::Term.new(:never, [])
+    refute(t.evaluate(fact('foo' => [100]), [], Factbase.new))
   end
 
   def test_size_matching
-    t = Factbase::Term.new(Factbase.new, :size, [:foo])
-    assert_equal(3, t.evaluate(fact('foo' => [42, 12, -90]), []))
-    assert_equal(0, t.evaluate(fact('bar' => 100), []))
+    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(Factbase.new, :exists, [:foo])
-    assert(t.evaluate(fact('foo' => [42, 12, -90]), []))
-    refute(t.evaluate(fact('bar' => 100), []))
+    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(Factbase.new, :absent, [:foo])
-    assert(t.evaluate(fact('z' => [42, 12, -90]), []))
-    refute(t.evaluate(fact('foo' => 100), []))
+    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(Factbase.new, :type, [:foo])
-    assert_equal('Integer', t.evaluate(fact('foo' => 42), []))
-    assert_equal('Integer', t.evaluate(fact('foo' => [42]), []))
-    assert_equal('Array', t.evaluate(fact('foo' => [1, 2, 3]), []))
-    assert_equal('String', t.evaluate(fact('foo' => 'Hello, world!'), []))
-    assert_equal('Float', t.evaluate(fact('foo' => 3.14), []))
-    assert_equal('Time', t.evaluate(fact('foo' => Time.now), []))
-    assert_equal('Integer', t.evaluate(fact('foo' => 1_000_000_000_000_000), []))
-    assert_equal('nil', t.evaluate(fact, []))
+    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(Factbase.new, :prev, [:foo])
-    assert_nil(t.evaluate(fact('foo' => 4), []))
-    assert_equal([4], t.evaluate(fact('foo' => 5), []))
+    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(Factbase.new, :at, [1, :foo])
-    assert_nil(t.evaluate(fact('foo' => 4), []))
-    assert_equal(5, t.evaluate(fact('foo' => [4, 5]), []))
+    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(Factbase.new, :something, [])
+    t = Factbase::Term.new(:something, [])
     msg = assert_raises(StandardError) do
-      t.evaluate(fact, [])
+      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(Factbase.new, :at, [])
+    t = Factbase::Term.new(:at, [])
     msg = assert_raises(StandardError) do
-      t.evaluate(fact, [])
+      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)
+  end
 end

data/test/test__helper.rb

@@ -22,7 +22,7 @@ require_relative '../lib/factbase'
 # Default methods for all tests.
 class Factbase::Test < Minitest::Test
   def fact(map = {})
-    require 'factbase/fact'
-    Factbase::Fact.new(Factbase.new, Mutex.new, map)
+    require_relative '../lib/factbase/fact'
+    Factbase::Fact.new(map)
   end
 end

data/test/test_factbase.rb

@@ -41,6 +41,12 @@ class TestFactbase < Factbase::Test
     end
   end
 
+  def test_converts_query_to_term
+    fb = Factbase.new
+    term = fb.to_term('(eq foo 42)')
+    assert_equal('(eq foo 42)', term.to_s)
+  end
+
   def test_simple_setting
     fb = Factbase.new
     fb.insert

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: factbase
 version: !ruby/object:Gem::Version
-  version: 0.7.5
+  version: 0.9.0
 platform: ruby
 authors:
 - Yegor Bugayenko
 bindir: bin
 cert_chain: []
-date: 2025-03-03 00:00:00.000000000 Z
+date: 2025-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: backtrace
@@ -162,24 +162,45 @@ files:
 - benchmark/bench_query.rb
 - benchmark/bench_taped.rb
 - factbase.gemspec
+- fixtures/stories/agg.yml
+- fixtures/stories/always.yml
+- fixtures/stories/as.yml
+- fixtures/stories/count.yml
+- fixtures/stories/eq.yml
+- fixtures/stories/gt.yml
+- fixtures/stories/join.yml
+- fixtures/stories/max.yml
+- fixtures/stories/min.yml
+- fixtures/stories/nth.yml
+- fixtures/stories/or.yml
+- fixtures/stories/sprintf.yml
+- fixtures/stories/sum.yml
 - lib/factbase.rb
 - lib/factbase/accum.rb
+- lib/factbase/cached/cached_fact.rb
+- lib/factbase/cached/cached_factbase.rb
+- lib/factbase/cached/cached_query.rb
+- lib/factbase/cached/cached_term.rb
 - lib/factbase/churn.rb
 - lib/factbase/fact.rb
 - lib/factbase/flatten.rb
+- lib/factbase/indexed/indexed_fact.rb
+- lib/factbase/indexed/indexed_factbase.rb
+- lib/factbase/indexed/indexed_query.rb
+- lib/factbase/indexed/indexed_term.rb
 - lib/factbase/inv.rb
 - lib/factbase/light.rb
 - lib/factbase/logged.rb
 - lib/factbase/pre.rb
 - lib/factbase/query.rb
-- lib/factbase/query_once.rb
 - lib/factbase/rules.rb
+- lib/factbase/sync/sync_factbase.rb
+- lib/factbase/sync/sync_query.rb
 - lib/factbase/syntax.rb
 - lib/factbase/tallied.rb
 - lib/factbase/taped.rb
 - lib/factbase/tee.rb
 - lib/factbase/term.rb
-- lib/factbase/term_once.rb
 - lib/factbase/terms/aggregates.rb
 - lib/factbase/terms/aliases.rb
 - lib/factbase/terms/casting.rb
@@ -195,6 +216,10 @@ files:
 - lib/factbase/to_xml.rb
 - lib/factbase/to_yaml.rb
 - renovate.json
+- test/factbase/cached/test_cached_factbase.rb
+- test/factbase/cached/test_cached_query.rb
+- test/factbase/indexed/test_indexed_query.rb
+- test/factbase/sync/test_sync_query.rb
 - test/factbase/terms/test_aggregates.rb
 - test/factbase/terms/test_aliases.rb
 - test/factbase/terms/test_casting.rb

data/lib/factbase/query_once.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../factbase'
-
-# Query with a cache, a decorator of another query.
-#
-# It is NOT thread-safe!
-#
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class Factbase::QueryOnce
-  # Constructor.
-  # @param [Factbase] fb Factbase
-  # @param [Factbase::Query] query Original query
-  # @param [Array<Hash>] maps Where to search
-  def initialize(fb, query, maps)
-    @fb = fb
-    @query = query
-    @maps = maps
-  end
-
-  # Iterate facts one by one.
-  # @param [Hash] params Optional params accessible in the query via the "$" symbol
-  # @yield [Fact] Facts one-by-one
-  # @return [Integer] Total number of facts yielded
-  def each(params = {}, &)
-    unless block_given?
-      return to_enum(__method__, params) if Factbase::Syntax.new(@fb, @query).to_term.abstract?
-      key = [@query.to_s, @maps.object_id]
-      before = @fb.cache[key]
-      @fb.cache[key] = to_enum(__method__, params).to_a if before.nil?
-      return @fb.cache[key]
-    end
-    @query.each(params, &)
-  end
-
-  # Read a single value.
-  # @param [Hash] params Optional params accessible in the query via the "$" symbol
-  # @return The value evaluated
-  def one(params = {})
-    @query.one(params)
-  end
-
-  # Delete all facts that match the query.
-  # @return [Integer] Total number of facts deleted
-  def delete!
-    @fb.cache.clear
-    @query.delete!
-  end
-end

data/lib/factbase/term_once.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-# SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
-# SPDX-License-Identifier: MIT
-
-require_relative '../factbase'
-
-# Term with a cache, a decorator of another term.
-#
-# It is NOT thread-safe!
-#
-# Author:: Yegor Bugayenko (yegor256@gmail.com)
-# Copyright:: Copyright (c) 2024-2025 Yegor Bugayenko
-# License:: MIT
-class Factbase::TermOnce < Factbase::Term
-  # Constructor.
-  # @param [Factbase::Term] term Original term
-  # @param [Hash] cache The cache
-  def initialize(term, cache)
-    super(nil, nil, nil) # just to please Rubocop
-    @term = term
-    @cache = cache
-    @text = @term.to_s
-    @cacheable = @term.static? && !@term.abstract?
-  end
-
-  # Does it match the fact?
-  # @param [Factbase::Fact] fact The fact
-  # @param [Array<Factbase::Fact>] maps All maps available
-  # @return [bool] TRUE if matches
-  def evaluate(fact, maps)
-    return @term.evaluate(fact, maps) unless @cacheable
-    key = [@text, maps.object_id]
-    before = @cache[key]
-    @cache[key] = @term.evaluate(nil, maps) if before.nil?
-    @cache[key]
-  end
-
-  # Simplify it if possible.
-  # @return [Factbase::Term] New term or itself
-  def simplify
-    @term.simplify
-  end
-
-  # Does it have any dependencies on a fact?
-  #
-  # If a term is static, it will return the same value for +evaluate+,
-  # no matter what is the fact given.
-  #
-  # @return [Boolean] TRUE if static
-  def static?
-    @term.static?
-  end
-
-  # Does it have any variables (+$foo+, for example) inside?
-  #
-  # @return [Boolean] TRUE if abstract
-  def abstract?
-    @term.abstract?
-  end
-
-  # Turns it into a string.
-  # @return [String] The string of it
-  def to_s
-    @term.to_s
-  end
-end