factbase 0.19.11 → 0.19.12

data/lib/factbase/indexed/indexed_gte.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: Copyright (c) 2024-2026 Yegor Bugayenko
+# SPDX-License-Identifier: MIT
+
+# Indexed term 'gte'.
+class Factbase::IndexedGte
+  def initialize(term, idx)
+    @term = term
+    @idx = idx
+  end
+
+  def predict(maps, _fb, params)
+    op1, op2 = @term.operands
+    return unless op1.is_a?(Symbol) && _scalar?(op2)
+    prop = op1.to_s
+    target = op2.is_a?(Symbol) ? params[op2.to_s]&.first : op2
+    return maps || [] if target.nil?
+    key = [maps.object_id, prop, :facts]
+    @idx[key] ||= { facts: [], count: 0 }
+    entry = @idx[key]
+    _feed(maps.to_a, entry, prop)
+    matched = _search(entry, target)
+    maps.respond_to?(:repack) ? maps.repack(matched) : matched
+  end
+
+  private
+
+  def _scalar?(item)
+    item.is_a?(String) || item.is_a?(Time) || item.is_a?(Integer) || item.is_a?(Float) || item.is_a?(Symbol)
+  end
+
+  def _feed(facts, entry, prop)
+    return unless entry[:count] < facts.size
+    facts[entry[:count]..].each do |fact|
+      fact[prop]&.each do |v|
+        entry[:facts] << [v, fact]
+      end
+    end
+    entry[:facts].sort_by! { |pair| pair[0] }
+    entry[:count] = facts.size
+  end
+
+  def _search(entry, target)
+    idx = entry[:facts].bsearch_index { |v, _| v >= target }
+    return [] if idx.nil?
+    facts = entry[:facts][idx..].map { |_, f| f }
+    facts.uniq!(&:object_id)
+    facts
+  end
+end

data/lib/factbase/indexed/indexed_lt.rb

@@ -44,6 +44,8 @@ class Factbase::IndexedLt
   def _search(entry, target)
     idx = entry[:facts].bsearch_index { |v, _| v >= target }
     res = idx.nil? ? entry[:facts] : entry[:facts][0...idx]
-    res.map { |_, f| f }.uniq(&:object_id)
+    facts = res.map { |_, f| f }
+    facts.uniq!(&:object_id)
+    facts
   end
 end

data/lib/factbase/indexed/indexed_lte.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: Copyright (c) 2024-2026 Yegor Bugayenko
+# SPDX-License-Identifier: MIT
+
+# Indexed term 'lte'.
+class Factbase::IndexedLte
+  def initialize(term, idx)
+    @term = term
+    @idx = idx
+  end
+
+  def predict(maps, _fb, params)
+    op1, op2 = @term.operands
+    return unless op1.is_a?(Symbol) && _scalar?(op2)
+    prop = op1.to_s
+    target = op2.is_a?(Symbol) ? params[op2.to_s]&.first : op2
+    return maps || [] if target.nil?
+    key = [maps.object_id, prop, :facts]
+    @idx[key] ||= { facts: [], count: 0 }
+    entry = @idx[key]
+    _feed(maps.to_a, entry, prop)
+    matched = _search(entry, target)
+    maps.respond_to?(:repack) ? maps.repack(matched) : matched
+  end
+
+  private
+
+  def _scalar?(item)
+    item.is_a?(String) || item.is_a?(Time) || item.is_a?(Integer) || item.is_a?(Float) || item.is_a?(Symbol)
+  end
+
+  def _feed(facts, entry, prop)
+    return unless entry[:count] < facts.size
+    facts[entry[:count]..].each do |fact|
+      fact[prop]&.each do |v|
+        entry[:facts] << [v, fact]
+      end
+    end
+    entry[:facts].sort_by! { |pair| pair[0] }
+    entry[:count] = facts.size
+  end
+
+  def _search(entry, target)
+    idx = entry[:facts].bsearch_index { |v, _| v > target }
+    res = idx.nil? ? entry[:facts] : entry[:facts][0...idx]
+    facts = res.map { |_, f| f }
+    facts.uniq!(&:object_id)
+    facts
+  end
+end

data/lib/factbase/indexed/indexed_not.rb

@@ -18,7 +18,7 @@ class Factbase::IndexedNot
     _feed(maps.to_a, entry) do
       sub.predict(maps, fb, params)
     end
-    return nil if entry[:facts].nil?
+    return if entry[:facts].nil?
     maps.respond_to?(:repack) ? maps.repack(entry[:facts]) : entry[:facts]
   end
 

data/lib/factbase/indexed/indexed_or.rb

@@ -11,7 +11,7 @@ class Factbase::IndexedOr
   end
 
   def predict(maps, fb, params)
-    return nil if @idx.nil?
+    return if @idx.nil?
     r = nil
     @term.operands.each do |o|
       n = o.predict(maps, fb, params)
@@ -21,7 +21,7 @@ class Factbase::IndexedOr
       end
       r = maps & [] if r.nil?
       r |= n.to_a
-      return maps if r.size > maps.size / 4 # it's big enough already
+      return maps if r.size > maps.size / 4
     end
     r
   end

data/lib/factbase/indexed/indexed_query.rb

@@ -37,11 +37,12 @@ class Factbase::IndexedQuery
   # @return [Integer] Total number of facts yielded
   def each(fb = @fb, params = {})
     return to_enum(__method__, fb, params) unless block_given?
-    a = @origin.each(fb, params).to_a
-    a.each do |f|
-      yield Factbase::IndexedFact.new(f, @idx, @fresh)
+    n = 0
+    @origin.each(fb, params) do |f|
+      yield(Factbase::IndexedFact.new(f, @idx, @fresh))
+      n += 1
     end
-    a.size
+    n
   end
 
   # Read a single value.
@@ -56,8 +57,6 @@ class Factbase::IndexedQuery
   # @param [Factbase] fb The factbase
   # @return [Integer] Total number of facts deleted
   def delete!(fb = @fb)
-    result = @origin.delete!(fb)
-    @idx.clear
-    result
+    @origin.delete!(fb).tap { @idx.clear }
   end
 end

data/lib/factbase/indexed/indexed_term.rb

@@ -5,15 +5,17 @@
 
 require 'tago'
 require_relative '../../factbase'
+require_relative '../indexed/indexed_absent'
+require_relative '../indexed/indexed_and'
 require_relative '../indexed/indexed_eq'
-require_relative '../indexed/indexed_lt'
+require_relative '../indexed/indexed_exists'
 require_relative '../indexed/indexed_gt'
-require_relative '../indexed/indexed_one'
+require_relative '../indexed/indexed_gte'
+require_relative '../indexed/indexed_lt'
+require_relative '../indexed/indexed_lte'
 require_relative '../indexed/indexed_not'
-require_relative '../indexed/indexed_exists'
-require_relative '../indexed/indexed_and'
+require_relative '../indexed/indexed_one'
 require_relative '../indexed/indexed_or'
-require_relative '../indexed/indexed_absent'
 require_relative '../indexed/indexed_unique'
 
 # Term with an index.
@@ -35,7 +37,7 @@ module Factbase::IndexedTerm
       return t.predict(maps, fb, params) if t.respond_to?(:predict)
     end
     m = :"#{@op}_predict"
-    return send(m, maps, fb, params) if respond_to?(m)
+    return __send__(m, maps, fb, params) if respond_to?(m)
     _init_indexes unless @indexes
     @indexes[@op].predict(maps, fb, params) if @indexes.key?(@op)
   end
@@ -46,7 +48,9 @@ module Factbase::IndexedTerm
     @indexes = {
       eq: Factbase::IndexedEq.new(self, @idx),
       lt: Factbase::IndexedLt.new(self, @idx),
+      lte: Factbase::IndexedLte.new(self, @idx),
       gt: Factbase::IndexedGt.new(self, @idx),
+      gte: Factbase::IndexedGte.new(self, @idx),
       one: Factbase::IndexedOne.new(self, @idx),
       exists: Factbase::IndexedExists.new(self, @idx),
       absent: Factbase::IndexedAbsent.new(self, @idx),

data/lib/factbase/indexed/indexed_unique.rb

@@ -10,7 +10,9 @@ class Factbase::IndexedUnique
     @idx = idx
   end
 
-  def predict(maps, _fb, _params)
-    maps
+  # rubocop:disable Elegant/NoNilReturn
+  def predict(_maps, _fb, _params)
+    nil
   end
+  # rubocop:enable Elegant/NoNilReturn
 end

data/lib/factbase/inv.rb

@@ -3,8 +3,8 @@
 # SPDX-FileCopyrightText: Copyright (c) 2024-2026 Yegor Bugayenko
 # SPDX-License-Identifier: MIT
 
-require 'others'
 require 'decoor'
+require 'others'
 require_relative '../factbase'
 
 # A decorator of a Factbase, that checks invariants on every set.
@@ -40,7 +40,7 @@ class Factbase::Inv
 
   def txn
     @fb.txn do |fbt|
-      yield Factbase::Inv.new(fbt, &@block)
+      yield(Factbase::Inv.new(fbt, &@block))
     end
   end
 
@@ -89,7 +89,7 @@ class Factbase::Inv
     def each(fb = @fb, params = {})
       return to_enum(__method__, fb, params) unless block_given?
       @query.each(fb, params) do |f|
-        yield Fact.new(f, @block)
+        yield(Fact.new(f, @block))
       end
     end
   end

data/lib/factbase/lazy_taped.rb

@@ -4,8 +4,8 @@
 # SPDX-License-Identifier: MIT
 
 require_relative '../factbase'
-require_relative 'taped'
 require_relative 'lazy_taped_hash'
+require_relative 'taped'
 
 # A lazy decorator of an Array with HashMaps that defers copying until modification.
 class Factbase::LazyTaped
@@ -22,7 +22,7 @@ class Factbase::LazyTaped
   # Returns the original map this copy was derived from.
   # Returns nil if the base hasn't been copied yet or if the fact is new.
   def source_of(copy)
-    return nil unless @copied
+    return unless @copied
     @copies.key(copy)
   end
 
@@ -76,21 +76,21 @@ class Factbase::LazyTaped
     is_copied = copied?
     unless is_copied
       @origin.each do |m|
-        yield _tape(m)
+        yield(_tape(m))
         yielded_size += 1
       end
     end
     staged = is_copied == copied? ? @staged : @staged[yielded_size..]
     staged&.each do |f|
       next if f.nil?
-      yield _tape(f)
+      yield(_tape(f))
     end
   end
 
   def delete_if
     ensure_copied!
     @staged.delete_if do |m|
-      r = yield m
+      r = yield(m)
       @deleted.append(source_of(m).object_id) if r
       r
     end
@@ -102,8 +102,7 @@ class Factbase::LazyTaped
 
   def repack(other)
     ensure_copied!
-    copied = other.map { |o| @copies[o] || o }
-    Factbase::Taped.new(copied, inserted: @inserted, deleted: @deleted, added: @added)
+    Factbase::Taped.new(other.map { |o| @copies[o] || o }, inserted: @inserted, deleted: @deleted, added: @added)
   end
 
   def &(other)
@@ -135,10 +134,9 @@ class Factbase::LazyTaped
 
   def _join(other)
     ensure_copied!
-    n = yield to_a, other.to_a
-    raise 'Cannot join with another Taped' if other.respond_to?(:inserted)
-    raise 'Can only join with array' unless other.is_a?(Array)
-    Factbase::Taped.new(n, inserted: @inserted, deleted: @deleted, added: @added)
+    raise(ArgumentError, 'Cannot join with another Taped') if other.respond_to?(:inserted)
+    raise(ArgumentError, 'Can only join with array') unless other.is_a?(Array)
+    Factbase::Taped.new(yield(to_a, other.to_a), inserted: @inserted, deleted: @deleted, added: @added)
   end
 
   def _track(copy, original)
@@ -147,7 +145,6 @@ class Factbase::LazyTaped
 
   def _tape(map)
     return LazyTapedHash.new(map, self, @added) unless copied?
-    copy = @copies[map] || map
-    Factbase::Taped::TapedHash.new(copy, @added)
+    Factbase::Taped::TapedHash.new(@copies[map] || map, @added)
   end
 end

data/lib/factbase/lazy_taped_hash.rb

@@ -65,7 +65,8 @@ class Factbase::LazyTaped
     end
 
     def method_missing(method, *, &)
-      current_map.send(method, *, &)
+      ensure_copied_map if method.to_s.end_with?('=', '!')
+      current_map.__send__(method, *, &)
     end
 
     def respond_to_missing?(method, include_private = false)

data/lib/factbase/light.rb

@@ -32,6 +32,6 @@ class Factbase::Light
   end
 
   def txn
-    raise 'You cannot start a transaction inside another transaction'
+    raise(StandardError, 'You cannot start a transaction inside another transaction')
   end
 end

data/lib/factbase/logged.rb

@@ -5,8 +5,8 @@
 
 require 'decoor'
 require 'others'
-require 'time'
 require 'tago'
+require 'time'
 require_relative 'syntax'
 
 # A decorator of a Factbase, that logs all operations.
@@ -15,16 +15,18 @@ require_relative 'syntax'
 # Copyright:: Copyright (c) 2024-2026 Yegor Bugayenko
 # License:: MIT
 class Factbase::Logged
+  MONO = Process::CLOCK_MONOTONIC
+
   # Ctor.
   # @param [Factbase] fb The factbase to decorate
   # @param [Object] log The logging facility
   # @param [Integer] time_tolerate How many seconds are OK per request
   # @param [Print] tube The tube to use, if log is NIL
   def initialize(fb, log = nil, time_tolerate: 1, tube: nil)
-    raise 'The "fb" is nil' if fb.nil?
+    raise(ArgumentError, 'The "fb" is nil') if fb.nil?
     @origin = fb
     if log.nil?
-      raise 'Either "log" or "tube" must be non-NIL' if tube.nil?
+      raise(ArgumentError, 'Either "log" or "tube" must be non-NIL') if tube.nil?
       @tube = tube
     else
       @tube = Tube.new(log, time_tolerate:)
@@ -34,10 +36,8 @@ class Factbase::Logged
   decoor(:origin)
 
   def insert
-    start = Time.now
-    f = @origin.insert
-    @tube.say(start, "Inserted new fact ##{@origin.size} in #{start.ago}")
-    Fact.new(f, tube: @tube)
+    @tube.say(Process.clock_gettime(MONO), "Inserted new fact ##{@origin.size} in #{Time.now.ago}")
+    Fact.new(@origin.insert, tube: @tube)
   end
 
   def query(term, maps = nil)
@@ -46,21 +46,21 @@ class Factbase::Logged
   end
 
   def txn
-    start = Time.now
+    mono = Process.clock_gettime(MONO)
     id = nil
     rollback = false
     r =
       @origin.txn do |fbt|
         id = fbt.object_id
-        yield Factbase::Logged.new(fbt, tube: @tube)
+        yield(Factbase::Logged.new(fbt, tube: @tube))
       rescue Factbase::Rollback => e
         rollback = true
-        raise e
+        raise(e)
       end
     if rollback
-      @tube.say(start, "Txn ##{id} rolled back in #{start.ago}")
+      @tube.say(mono, "Txn ##{id} rolled back in #{Time.now.ago}")
     else
-      @tube.say(start, "Txn ##{id} touched #{r} in #{start.ago}")
+      @tube.say(mono, "Txn ##{id} touched #{r} in #{Time.now.ago}")
     end
     r
   end
@@ -72,13 +72,13 @@ class Factbase::Logged
       @time_tolerate = time_tolerate
     end
 
-    def say(start, msg)
+    def say(start_mono, msg)
       m = :debug
-      if Time.now - start > @time_tolerate
+      if Process.clock_gettime(Factbase::Logged::MONO) - start_mono > @time_tolerate
         msg = "#{msg} (slow!)"
         m = :warn
       end
-      @log.send(m, msg)
+      @log.__send__(m, msg)
     end
   end
 
@@ -108,14 +108,16 @@ class Factbase::Logged
     end
 
     others do |*args|
-      start = Time.now
+      mono = Process.clock_gettime(Factbase::Logged::MONO) if args[0].to_s.end_with?('=')
       r = @fact.method_missing(*args)
       k = args[0].to_s
       v = args[1]
-      s = v.is_a?(Time) ? v.utc.iso8601 : v.to_s
-      s = v.to_s.inspect if v.is_a?(String)
-      s = "#{s[0..(MAX_LENGTH / 2)]}...#{s[(-MAX_LENGTH / 2)..]}" if s.length > MAX_LENGTH
-      @tube.say(start, "Set '#{k[0..-2]}' to #{s} (#{v.class})") if k.end_with?('=')
+      if k.end_with?('=')
+        s = v.is_a?(Time) ? v.utc.iso8601 : v.to_s
+        s = v.to_s.inspect if v.is_a?(String)
+        s = "#{s[0..(MAX_LENGTH / 2)]}...#{s[(-MAX_LENGTH / 2)..]}" if s.length > MAX_LENGTH
+        @tube.say(mono, "Set '#{k[0..-2]}' to #{s} (#{v.class})")
+      end
       r
     end
   end
@@ -137,26 +139,28 @@ class Factbase::Logged
 
     def each(fb = @fb, params = {}, &)
       return to_enum(__method__, fb, params) unless block_given?
-      start = Time.now
+      mono = Process.clock_gettime(Factbase::Logged::MONO)
       r = nil
       qry = @fb.query(@term, @maps)
       tail =
         Factbase::Logged.elapsed do
           r = qry.each(fb, params, &)
         end
-      raise ".query(#{@term.to_s.inspect}).each() of #{qry.class} returned #{r.class}" unless r.is_a?(Integer)
+      unless r.is_a?(Integer)
+        raise(StandardError, ".query(#{@term.to_s.inspect}).each() of #{qry.class} returned #{r.class}")
+      end
       q = Factbase::Syntax.new(@term).to_term.to_s
       q = "#{q} with {#{params.map { |k, v| "#{k}=#{v}" }.join(', ')}}" if params.is_a?(Hash) && !params.empty?
       if r.zero?
-        @tube.say(start, "Zero/#{@fb.size} facts found by #{q} #{tail}")
+        @tube.say(mono, "Zero/#{@fb.size} facts found by #{q} #{tail}")
       else
-        @tube.say(start, "Found #{r}/#{@fb.size} fact(s) by #{q} #{tail}")
+        @tube.say(mono, "Found #{r}/#{@fb.size} fact(s) by #{q} #{tail}")
       end
       r
     end
 
     def one(fb = @fb, params = {})
-      start = Time.now
+      mono = Process.clock_gettime(Factbase::Logged::MONO)
       q = Factbase::Syntax.new(@term).to_term.to_s
       r = nil
       tail =
@@ -164,36 +168,35 @@ class Factbase::Logged
           r = @fb.query(@term, @maps).one(fb, params)
         end
       if r.nil?
-        @tube.say(start, "Nothing found by '#{q}' #{tail}")
+        @tube.say(mono, "Nothing found by '#{q}' #{tail}")
       else
-        @tube.say(start, "Found #{r} (#{r.class}) by '#{q}' #{tail}")
+        @tube.say(mono, "Found #{r} (#{r.class}) by '#{q}' #{tail}")
       end
       r
     end
 
     def delete!(fb = @fb)
       r = nil
-      start = Time.now
+      mono = Process.clock_gettime(Factbase::Logged::MONO)
       before = @fb.size
       tail =
         Factbase::Logged.elapsed do
           r = @fb.query(@term, @maps).delete!(fb)
         end
-      raise ".delete! of #{@term.class} returned #{r.class}" unless r.is_a?(Integer)
+      raise(StandardError, ".delete! of #{@term.class} returned #{r.class}") unless r.is_a?(Integer)
       if before.zero?
-        @tube.say(start, "There were no facts, nothing deleted by #{@term} #{tail}")
+        @tube.say(mono, "There were no facts, nothing deleted by #{@term} #{tail}")
       elsif r.zero?
-        @tube.say(start, "No facts out of #{before} deleted by #{@term} #{tail}")
+        @tube.say(mono, "No facts out of #{before} deleted by #{@term} #{tail}")
       else
-        @tube.say(start, "Deleted #{r} fact(s) out of #{before} by #{@term} #{tail}")
+        @tube.say(mono, "Deleted #{r} fact(s) out of #{before} by #{@term} #{tail}")
       end
       r
     end
   end
 
   def self.elapsed
-    start = Time.now
     yield
-    "in #{start.ago}"
+    "in #{Time.now.ago}"
   end
 end

data/lib/factbase/pre.rb

@@ -3,8 +3,8 @@
 # SPDX-FileCopyrightText: Copyright (c) 2024-2026 Yegor Bugayenko
 # SPDX-License-Identifier: MIT
 
-require 'loog'
 require 'decoor'
+require 'loog'
 require_relative '../factbase'
 
 # A decorator of a +Factbase+, that runs a provided block on every +insert+.
@@ -26,7 +26,7 @@ class Factbase::Pre
   decoor(:fb)
 
   def initialize(fb, &block)
-    raise 'The "fb" is nil' if fb.nil?
+    raise(ArgumentError, 'The "fb" is nil') if fb.nil?
     @fb = fb
     @block = block
   end
@@ -39,7 +39,7 @@ class Factbase::Pre
 
   def txn
     @fb.txn do |fbt|
-      yield Factbase::Pre.new(fbt, &@block)
+      yield(Factbase::Pre.new(fbt, &@block))
     end
   end
 end

data/lib/factbase/query.rb

@@ -52,13 +52,12 @@ class Factbase::Query
       extras = {}
       f = Factbase::Fact.new(m)
       f = Factbase::Tee.new(f, params)
-      a = Factbase::Accum.new(f, extras, false)
-      r = @term.evaluate(a, @maps, fb)
+      r = @term.evaluate(Factbase::Accum.new(f, extras, false), @maps, fb)
       unless r.is_a?(TrueClass) || r.is_a?(FalseClass)
-        raise "Unexpected evaluation result of type #{r.class}, must be Boolean at #{@term.inspect}"
+        raise(ArgumentError, "Unexpected evaluation result of type #{r.class}, must be Boolean at #{@term.inspect}")
       end
       next unless r
-      yield Factbase::Accum.new(f, extras, true)
+      yield(Factbase::Accum.new(f, extras, true))
       yielded += 1
     end
     yielded
@@ -72,7 +71,7 @@ class Factbase::Query
     params = params.transform_keys(&:to_s) if params.is_a?(Hash)
     r = @term.evaluate(Factbase::Tee.new(Factbase::Fact.new({}), params), @maps, fb)
     unless %w[String Integer Float Time Array NilClass].include?(r.class.to_s)
-      raise "Incorrect type #{r.class} returned by #{@term.inspect}"
+      raise(StandardError, "Incorrect type #{r.class} returned by #{@term.inspect}")
     end
     r
   end

data/lib/factbase/rules.rb

@@ -28,11 +28,11 @@ class Factbase::Rules
   decoor(:fb)
 
   def initialize(fb, rules, check = Check.new(rules), uid: nil)
-    raise 'The "fb" is nil' if fb.nil?
+    raise(ArgumentError, 'The "fb" is nil') if fb.nil?
     @fb = fb
-    raise 'The "rules" is nil' if rules.nil?
+    raise(ArgumentError, 'The "rules" is nil') if rules.nil?
     @rules = rules
-    raise 'The "check" is nil' if check.nil?
+    raise(ArgumentError, 'The "check" is nil') if check.nil?
     @check = check
     @uid = uid
   end
@@ -51,7 +51,7 @@ class Factbase::Rules
     @check = later
     @fb.txn do |fbt|
       churn = Factbase::Churn.new
-      yield Factbase::Tallied.new(Factbase::Rules.new(fbt, @rules, @check, uid: @uid), churn)
+      yield(Factbase::Tallied.new(Factbase::Rules.new(fbt, @rules, @check, uid: @uid), churn))
       @check = before
       unless churn.zero?
         fbt.query('(always)').each do |f|
@@ -107,7 +107,7 @@ class Factbase::Rules
     def each(fb = @fb, params = {})
       return to_enum(__method__, fb, params) unless block_given?
       @query.each(fb, params) do |f|
-        yield Fact.new(f, @check, fb)
+        yield(Fact.new(f, @check, fb))
       end
     end
   end
@@ -123,7 +123,7 @@ class Factbase::Rules
     def it(fact, fb)
       return if Factbase::Syntax.new(@expr).to_term.evaluate(fact, [], fb)
       e = "#{@expr[0..32]}..." if @expr.length > 32
-      raise "The fact doesn't match the #{e.inspect} rule: #{fact}"
+      raise(ArgumentError, "The fact doesn't match the #{e.inspect} rule: #{fact}")
     end
   end
 
@@ -140,7 +140,7 @@ class Factbase::Rules
       return if @uid.nil?
       a = fact[@uid]
       return if a.nil?
-      raise "More than one #{@uid.inspect} in the fact: #{a}" if a.size > 1
+      raise(ArgumentError, "More than one #{@uid.inspect} in the fact: #{a}") if a.size > 1
       @facts << a.first
     end
 
@@ -148,7 +148,7 @@ class Factbase::Rules
       return true if @uid.nil?
       a = fact[@uid]
       return true if a.nil?
-      raise "More than one #{@uid.inspect} in the fact: #{a}" if a.size > 1
+      raise(ArgumentError, "More than one #{@uid.inspect} in the fact: #{a}") if a.size > 1
       @facts.include?(a.first)
     end
   end

data/lib/factbase/sync/sync_factbase.rb

@@ -43,7 +43,7 @@ class Factbase::SyncFactbase
   # @param [Array<Hash>] maps Possible maps to use
   def query(term, maps = nil)
     term = to_term(term) if term.is_a?(String)
-    require_relative 'sync_query'
+    require_relative('sync_query')
     Factbase::SyncQuery.new(@origin.query(term, maps), @monitor, self)
   end
 
@@ -53,7 +53,7 @@ class Factbase::SyncFactbase
   def txn
     try_lock do
       @origin.txn do |fbt|
-        yield Factbase::SyncFactbase.new(fbt, @monitor)
+        yield(Factbase::SyncFactbase.new(fbt, @monitor))
       end
     end
   end