factbase 0.11.2 → 0.12.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be29589dd79cd9d1737bc03dc28e3e4dc6c3115fc09c3369e8d4b617f8a57829
-  data.tar.gz: 57283b8114c03feaf19bbbae3a2b117ab1399026c0b5b9af2059af3356978717
+  metadata.gz: 1ba24c42ea5df6fab3bfcf4477eff165173de5eb224c80e8bd1b1eeda5a9036d
+  data.tar.gz: b0f9362eec0b148f451dcbc94012db27ac97a02e4c6fbe48e0303a33d5f46c9e
 SHA512:
-  metadata.gz: afad81287f3b28820595f309a6f538a4415541fb212c2df31b034b0fa512698703db6c8be4c3c4389ec6cf355a944b6dc069ebf68b53fe085648d55a0cf1c10c
-  data.tar.gz: a566f40422aeb136517330c70c88348dbd3ea21786ab999de532a709ccdd09394f22cb64da490c0ccba0ef483ba46d2e2416865b4b66856e626904ac05b0809c
+  metadata.gz: e6460f586f42569fac5f6dedd783ab68e47f1fc2e7e05932033003586b40339044005d383306fce26f3f56a375d7a33d3a2798d3b84356e76c09550c6375e3d9
+  data.tar.gz: c8067f91613d87093ebf824c4800298e2b2e25654fc4ad9b5c3fed4c26e8265e19968a8eac887e5b541de48e5ebc531df6925c4ad73c48b49b1cb80ba429e5b7

data/.rultor.yml

@@ -1,4 +1,3 @@
-
 # SPDX-FileCopyrightText: Copyright (c) 2024-2025 Yegor Bugayenko
 # SPDX-License-Identifier: MIT
 ---

data/benchmark/bench_query.rb

@@ -6,7 +6,7 @@
 require_relative '../lib/factbase'
 
 def bench_query(bmk, fb)
-  total = 500
+  total = 20_000
   total.times do |i|
     f = fb.insert
     f.id = i
@@ -15,6 +15,7 @@ def bench_query(bmk, fb)
     f.cost = rand(1..100)
     f.foo = rand(0.0..100.0).round(3)
     f.bar = rand(100..300)
+    f.blue = 1 if rand > 0.5
     f.seenBy = "User#{i}" if i.even?
     f.zzz = "Extra#{i}" if (i % 10).zero?
   end
@@ -25,6 +26,7 @@ def bench_query(bmk, fb)
     '(gt cost 50)',
     '(eq title \'Object Thinking 5000\')',
     '(and (eq foo 42.998) (or (gt bar 200) (absent zzz)))',
+    '(and (exists foo) (not (exists blue)))',
     '(eq id (agg (always) (max id)))',
     '(join "c<=cost,b<=bar" (eq id (agg (always) (max id))))'
   ].each do |q|

data/lib/factbase/indexed/indexed_term.rb

@@ -120,11 +120,20 @@ module Factbase::IndexedTerm
       end
       r
     when :not
-      r = @operands.first.predict(maps, params)
+      if @idx[key].nil?
+        yes = @operands.first.predict(maps, params)
+        if yes.nil?
+          @idx[key] = { r: nil }
+        else
+          yes = yes.to_a.to_set
+          @idx[key] = { r: maps.to_a.reject { |m| yes.include?(m) } }
+        end
+      end
+      r = @idx[key][:r]
       if r.nil?
         nil
       else
-        (maps & []) | (maps.to_a - r.to_a)
+        (maps & []) | r
       end
     end
   end

data/lib/factbase/rules.rb

@@ -14,7 +14,7 @@ require_relative '../factbase/syntax'
 # to insert a fact without this property to lead to a runtime error. Here is how:
 #
 #  fb = Factbase.new
-#  fb = Factabase::Rules.new(fb, '(exists foo)')
+#  fb = Factbase::Rules.new(fb, '(exists foo)')
 #  fb.txn do |fbt|
 #    f = fbt.insert
 #    f.bar = 3 # No exception here

data/lib/factbase/terms/aggregates.rb

@@ -28,9 +28,9 @@ module Factbase::Aggregates
   def nth(_fact, maps, _fb)
     assert_args(2)
     pos = @operands[0]
-    raise "An integer expected, but #{pos} provided" unless pos.is_a?(Integer)
+    raise "An integer is expected, but #{pos} provided" unless pos.is_a?(Integer)
     k = @operands[1]
-    raise "A symbol expected, but #{k} provided" unless k.is_a?(Symbol)
+    raise "A symbol is expected, but #{k} provided" unless k.is_a?(Symbol)
     m = maps[pos]
     return nil if m.nil?
     m[k.to_s]
@@ -39,7 +39,7 @@ module Factbase::Aggregates
   def first(_fact, maps, _fb)
     assert_args(1)
     k = @operands[0]
-    raise "A symbol expected, but #{k} provided" unless k.is_a?(Symbol)
+    raise "A symbol is expected, but #{k} provided" unless k.is_a?(Symbol)
     first = maps[0]
     return nil if first.nil?
     first[k.to_s]
@@ -47,7 +47,7 @@ module Factbase::Aggregates
 
   def sum(_fact, maps, _fb)
     k = @operands[0]
-    raise "A symbol expected, but '#{k}' provided" unless k.is_a?(Symbol)
+    raise "A symbol is expected, but '#{k}' provided" unless k.is_a?(Symbol)
     sum = 0
     maps.each do |m|
       vv = m[k.to_s]
@@ -63,9 +63,9 @@ module Factbase::Aggregates
   def agg(fact, maps, fb)
     assert_args(2)
     selector = @operands[0]
-    raise "A term expected, but '#{selector}' provided" unless selector.is_a?(Factbase::Term)
+    raise "A term is expected, but '#{selector}' provided" unless selector.is_a?(Factbase::Term)
     term = @operands[1]
-    raise "A term expected, but '#{term}' provided" unless term.is_a?(Factbase::Term)
+    raise "A term is expected, but '#{term}' provided" unless term.is_a?(Factbase::Term)
     subset = fb.query(selector, maps).each(fb, fact).to_a
     term.evaluate(nil, subset, fb)
   end
@@ -73,7 +73,7 @@ module Factbase::Aggregates
   def empty(fact, maps, fb)
     assert_args(1)
     term = @operands[0]
-    raise "A term expected, but '#{term}' provided" unless term.is_a?(Factbase::Term)
+    raise "A term is expected, but '#{term}' provided" unless term.is_a?(Factbase::Term)
     # rubocop:disable Lint/UnreachableLoop
     fb.query(term, maps).each(fb, fact) do
       return false
@@ -84,7 +84,7 @@ module Factbase::Aggregates
 
   def _best(maps)
     k = @operands[0]
-    raise "A symbol expected, but #{k} provided" unless k.is_a?(Symbol)
+    raise "A symbol is expected, but #{k} provided" unless k.is_a?(Symbol)
     best = nil
     maps.each do |m|
       vv = m[k.to_s]

data/lib/factbase/terms/aliases.rb

@@ -14,7 +14,7 @@ module Factbase::Aliases
   def as(fact, maps, fb)
     assert_args(2)
     a = @operands[0]
-    raise "A symbol expected as first argument of 'as'" unless a.is_a?(Symbol)
+    raise "A symbol is expected as first argument of 'as'" unless a.is_a?(Symbol)
     vv = _values(1, fact, maps, fb)
     vv&.each { |v| fact.send(:"#{a}=", v) }
     true
@@ -23,13 +23,13 @@ module Factbase::Aliases
   def join(fact, maps, fb)
     assert_args(2)
     jumps = @operands[0]
-    raise "A string expected as first argument of 'join'" unless jumps.is_a?(String)
+    raise "A string is expected as first argument of 'join'" unless jumps.is_a?(String)
     jumps = jumps.split(',')
       .map(&:strip)
       .map { |j| j.split('<=').map(&:strip) }
       .map { |j| j.size == 1 ? [j[0], j[0]] : j }
     term = @operands[1]
-    raise "A term expected, but '#{term}' provided" unless term.is_a?(Factbase::Term)
+    raise "A term is expected, but '#{term}' provided" unless term.is_a?(Factbase::Term)
     subset = fb.query(term, maps).each(fb, fact).to_a
     subset.each do |s|
       jumps.each do |to, from|

data/lib/factbase/terms/debug.rb

@@ -14,9 +14,34 @@ module Factbase::Debug
   def traced(fact, maps, fb)
     assert_args(1)
     t = @operands[0]
-    raise "A term expected, but '#{t}' provided" unless t.is_a?(Factbase::Term)
+    raise "A term is expected, but '#{t}' provided" unless t.is_a?(Factbase::Term)
     r = t.evaluate(fact, maps, fb)
     puts "#{self} -> #{r}"
     r
   end
+
+  def assert(fact, maps, fb)
+    assert_args(2)
+    message = @operands[0]
+    unless message.is_a?(String)
+      raise ArgumentError,
+            "A string is expected as first argument of 'assert', but '#{message}' provided"
+    end
+    t = @operands[1]
+    unless t.is_a?(Factbase::Term)
+      raise ArgumentError,
+            "A term is expected as second argument of 'assert', but '#{t}' provided"
+    end
+    result = t.evaluate(fact, maps, fb)
+    # Convert result to boolean-like evaluation
+    # Arrays are truthy if they contain at least one truthy element
+    truthy =
+      if result.is_a?(Array)
+        result.any? { |v| v && v != 0 }
+      else
+        result && result != 0
+      end
+    raise message unless truthy
+    true
+  end
 end

data/lib/factbase/terms/logical.rb

@@ -119,6 +119,6 @@ module Factbase::Logical
     val = val[0] if val.respond_to?(:each)
     return false if val.nil?
     return val if val.is_a?(TrueClass) || val.is_a?(FalseClass)
-    raise "Boolean expected, while #{val.class} received from #{@operands[pos]}"
+    raise "Boolean is expected, while #{val.class} received from #{@operands[pos]}"
   end
 end

data/lib/factbase/terms/strings.rb

@@ -25,10 +25,10 @@ module Factbase::Strings
     assert_args(2)
     str = _values(0, fact, maps, fb)
     return false if str.nil?
-    raise 'Exactly one string expected' unless str.size == 1
+    raise 'Exactly one string is expected' unless str.size == 1
     re = _values(1, fact, maps, fb)
     raise 'Regexp is nil' if re.nil?
-    raise 'Exactly one regexp expected' unless re.size == 1
+    raise 'Exactly one regexp is expected' unless re.size == 1
     str[0].to_s.match?(re[0])
   end
 end

data/lib/factbase/version.rb

@@ -9,5 +9,5 @@
 # License:: MIT
 class Factbase
   # Current version of the gem (changed by .rultor.yml on every release)
-  VERSION = '0.11.2' unless const_defined?(:VERSION)
+  VERSION = '0.12.1' unless const_defined?(:VERSION)
 end

data/lib/factbase.rb

@@ -102,8 +102,8 @@ class Factbase
   #
   # A fact, when inserted, is empty. It doesn't contain any properties.
   #
-  # The operation is thread-safe, meaning that you different threads may
-  # insert facts parallel without breaking the consistency of the factbase.
+  # The operation is thread-safe, meaning that different threads may
+  # insert facts in parallel without breaking the consistency of the factbase.
   #
   # @return [Factbase::Fact] The fact just inserted
   def insert

data/test/factbase/terms/test_debug.rb

@@ -20,7 +20,7 @@ class TestDebug < Factbase::Test
 
   def test_traced_raises
     e = assert_raises(StandardError) { Factbase::Term.new(:traced, ['foo']).evaluate(fact, [], Factbase.new) }
-    assert_match(/A term expected, but 'foo' provided/, e.message)
+    assert_match(/A term is expected, but 'foo' provided/, e.message)
   end
 
   def test_traced_raises_when_too_many_args
@@ -33,4 +33,79 @@ class TestDebug < Factbase::Test
       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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: factbase
 version: !ruby/object:Gem::Version
-  version: 0.11.2
+  version: 0.12.1
 platform: ruby
 authors:
 - Yegor Bugayenko