factbase 0.19.11 → 0.19.12

data/lib/factbase/syntax.rb

@@ -43,7 +43,7 @@ class Factbase::Syntax
   rescue StandardError => e
     err = "#{e.message} (#{Backtrace.new(e)}) in \"#{@query}\""
     err = "#{err}, tokens: #{@tokens}" unless @tokens.nil?
-    raise Broken, err
+    raise(Broken, err)
   end
 
   private
@@ -52,12 +52,12 @@ class Factbase::Syntax
   # @return [Term] The term detected
   def build
     @tokens ||= to_tokens
-    raise 'No tokens' if @tokens.empty?
+    raise(StandardError, 'No tokens') if @tokens.empty?
     @ast ||= to_ast(@tokens, 0)
-    raise "Too many terms (#{@ast[1]} != #{@tokens.size})" if @ast[1] != @tokens.size
+    raise(ArgumentError, "Too many terms (#{@ast[1]} != #{@tokens.size})") if @ast[1] != @tokens.size
     t = @ast[0]
-    raise 'No terms found in the AST' if t.nil?
-    raise "#{t.class.name} is not an instance of Term" unless t.is_a?(Factbase::Term)
+    raise(StandardError, 'No terms found in the AST') if t.nil?
+    raise(ArgumentError, "#{t.class.name} is not an instance of Term") unless t.is_a?(Factbase::Term)
     t
   end
 
@@ -73,25 +73,24 @@ class Factbase::Syntax
   # @param [Integer] at Position to start parsing from
   # @return [Array<Factbase::Term,Integer>] The term detected and ending position
   def to_ast(tokens, at)
-    raise "Closing too soon at ##{at}" if tokens[at] == :close
+    raise(StandardError, "Closing too soon at ##{at}") if tokens[at] == :close
     return [tokens[at], at + 1] unless tokens[at] == :open
     at += 1
     op = tokens[at]
-    raise 'No token found' if op == :close
+    raise(StandardError, 'No token found') if op == :close
     operands = []
     at += 1
     loop do
-      raise "End of token stream at ##{at}" if tokens[at].nil?
+      raise(StandardError, "End of token stream at ##{at}") if tokens[at].nil?
       break if tokens[at] == :close
       (operand, at1) = to_ast(tokens, at)
-      raise "Stuck at position ##{at}" if at == at1
-      raise "Jump back at position ##{at}" if at1 < at
+      raise(StandardError, "Stuck at position ##{at}") if at == at1
+      raise(StandardError, "Jump back at position ##{at}") if at1 < at
       at = at1
       operands << operand
       break if tokens[at] == :close
     end
-    t = Factbase::Term.new(op, operands)
-    [t, at + 1]
+    [Factbase::Term.new(op, operands), at + 1]
   end
 
   # Turns a query into an array of tokens.
@@ -100,7 +99,7 @@ class Factbase::Syntax
     list = []
     acc = ''
     quotes = ['\'', '"']
-    spaces = [' ', ')']
+    spaces = [' ', ')', "\n", "\t", "\r"]
     string = false
     comment = false
     @query.to_s.chars.each do |c|
@@ -128,26 +127,26 @@ class Factbase::Syntax
       when ')'
         list << :close
       when ' ', "\n", "\t", "\r"
-        # ignore it
+        next
       else
         acc += c
       end
     end
-    raise 'String not closed' if string
+    raise(StandardError, 'String not closed') if string
     list.map do |t|
       if t.is_a?(Symbol)
         t
       elsif t.start_with?('\'', '"')
-        raise 'String literal can\'t be empty' if t.length <= 2
+        raise(ArgumentError, 'String literal can\'t be empty') if t.length <= 2
         t[1..-2]
       elsif t.match?(/^(\+|-)?[0-9]+$/)
-        t.to_i
+        Integer(t, 10)
       elsif t.match?(/^(\+|-)?[0-9]+\.[0-9]+(e(\+|-)[0-9]+)?$/)
-        t.to_f
+        Float(t)
       elsif t.match?(/^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z$/)
         Time.parse(t)
       else
-        raise "Wrong symbol format (#{t})" unless t.match?(/^([_a-z][a-zA-Z0-9_]*|\$[_a-z]+)$/)
+        raise(ArgumentError, "Wrong symbol format (#{t})") unless t.match?(/^([_a-z][a-zA-Z0-9_]*|\$[_a-z]+)$/)
         t.to_sym
       end
     end

data/lib/factbase/tallied.rb

@@ -18,7 +18,7 @@ class Factbase::Tallied
   attr_reader :churn
 
   def initialize(fb, churn = Factbase::Churn.new)
-    raise 'The "fb" is nil' if fb.nil?
+    raise(ArgumentError, 'The "fb" is nil') if fb.nil?
     @fb = fb
     @churn = churn
   end
@@ -26,9 +26,8 @@ class Factbase::Tallied
   decoor(:fb)
 
   def insert
-    f = Fact.new(@fb.insert, @churn)
     @churn.append(1, 0, 0)
-    f
+    Fact.new(@fb.insert, @churn)
   end
 
   def query(query, maps = nil)
@@ -39,13 +38,13 @@ class Factbase::Tallied
     before = @churn.dup
     commit = false
     @fb.txn do |fbt|
-      catch :rollback do
-        yield Factbase::Tallied.new(fbt, @churn)
+      catch(:rollback) do
+        yield(Factbase::Tallied.new(fbt, @churn))
         commit = true
       end
     rescue Factbase::Rollback => e
       @churn = before
-      raise e
+      raise(e)
     ensure
       @churn = before unless commit
     end
@@ -96,7 +95,7 @@ class Factbase::Tallied
     def each(fb = @fb, params = {}, &)
       return to_enum(__method__, fb, params) unless block_given?
       @query.each(fb, params) do |f|
-        yield Fact.new(f, @churn)
+        yield(Fact.new(f, @churn))
       end
     end
 

data/lib/factbase/taped.rb

@@ -52,13 +52,13 @@ class Factbase::Taped
   def each
     return to_enum(__method__) unless block_given?
     @origin.each do |m|
-      yield TapedHash.new(m, @added)
+      yield(TapedHash.new(m, @added))
     end
   end
 
   def delete_if
     @origin.delete_if do |m|
-      r = yield m
+      r = yield(m)
       @deleted.append(m.object_id) if r
       r
     end
@@ -153,14 +153,8 @@ class Factbase::Taped
   private
 
   def join(other)
-    n = yield @origin.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(@origin.to_a, other.to_a), inserted: @inserted, deleted: @deleted, added: @added)
   end
 end

data/lib/factbase/tee.rb

@@ -16,9 +16,9 @@ class Factbase::Tee
   # @param [Factbase::Fact] fact Primary fact to use for reading
   # @param [Factbase::Fact] upper Fact to access with a "$" prefix
   def initialize(fact, upper)
-    raise 'Fact is nil' if fact.nil?
+    raise(ArgumentError, 'Fact is nil') if fact.nil?
     @fact = fact
-    raise 'Upper is nil' if upper.nil?
+    raise(ArgumentError, 'Upper is nil') if upper.nil?
     @upper = upper
   end
 

data/lib/factbase/term.rb

@@ -7,60 +7,60 @@ require 'backtrace'
 require_relative '../factbase'
 require_relative 'fact'
 require_relative 'tee'
-require_relative 'terms/unique'
-require_relative 'terms/prev'
+require_relative 'terms/absent'
+require_relative 'terms/agg'
+require_relative 'terms/always'
+require_relative 'terms/and'
+require_relative 'terms/as'
+require_relative 'terms/assert'
 require_relative 'terms/concat'
-require_relative 'terms/sprintf'
-require_relative 'terms/matches'
 require_relative 'terms/contains'
-require_relative 'terms/starts_with'
+require_relative 'terms/count'
+require_relative 'terms/defn'
+require_relative 'terms/div'
+require_relative 'terms/either'
+require_relative 'terms/empty'
 require_relative 'terms/ends_with'
-require_relative 'terms/traced'
-require_relative 'terms/assert'
 require_relative 'terms/env'
-require_relative 'terms/defn'
-require_relative 'terms/undef'
-require_relative 'terms/as'
-require_relative 'terms/join'
+require_relative 'terms/eq'
 require_relative 'terms/exists'
-require_relative 'terms/absent'
-require_relative 'terms/size'
-require_relative 'terms/type'
-require_relative 'terms/nil'
-require_relative 'terms/many'
-require_relative 'terms/one'
-require_relative 'terms/to_string'
-require_relative 'terms/to_integer'
-require_relative 'terms/to_float'
-require_relative 'terms/to_time'
-require_relative 'terms/sorted'
-require_relative 'terms/inverted'
+require_relative 'terms/first'
+require_relative 'terms/gt'
+require_relative 'terms/gte'
 require_relative 'terms/head'
-require_relative 'terms/plus'
-require_relative 'terms/minus'
-require_relative 'terms/times'
-require_relative 'terms/div'
-require_relative 'terms/zero'
-require_relative 'terms/eq'
+require_relative 'terms/inverted'
+require_relative 'terms/join'
 require_relative 'terms/lt'
 require_relative 'terms/lte'
-require_relative 'terms/gt'
-require_relative 'terms/gte'
-require_relative 'terms/always'
+require_relative 'terms/many'
+require_relative 'terms/matches'
+require_relative 'terms/max'
+require_relative 'terms/min'
+require_relative 'terms/minus'
 require_relative 'terms/never'
+require_relative 'terms/nil'
 require_relative 'terms/not'
-require_relative 'terms/or'
-require_relative 'terms/and'
-require_relative 'terms/when'
-require_relative 'terms/either'
-require_relative 'terms/count'
-require_relative 'terms/first'
 require_relative 'terms/nth'
+require_relative 'terms/one'
+require_relative 'terms/or'
+require_relative 'terms/plus'
+require_relative 'terms/prev'
+require_relative 'terms/size'
+require_relative 'terms/sorted'
+require_relative 'terms/sprintf'
+require_relative 'terms/starts_with'
 require_relative 'terms/sum'
-require_relative 'terms/agg'
-require_relative 'terms/empty'
-require_relative 'terms/min'
-require_relative 'terms/max'
+require_relative 'terms/times'
+require_relative 'terms/to_float'
+require_relative 'terms/to_integer'
+require_relative 'terms/to_string'
+require_relative 'terms/to_time'
+require_relative 'terms/traced'
+require_relative 'terms/type'
+require_relative 'terms/undef'
+require_relative 'terms/unique'
+require_relative 'terms/when'
+require_relative 'terms/zero'
 
 # Term.
 #
@@ -90,13 +90,7 @@ require_relative 'terms/max'
 # Copyright:: Copyright (c) 2024-2026 Yegor Bugayenko
 # License:: MIT
 class Factbase::Term < Factbase::TermBase
-  # The operator of this term
-  # @return [Symbol] The operator
-  attr_reader :op
-
-  # The operands of this term
-  # @return [Array] The operands
-  attr_reader :operands
+  attr_reader :op, :operands
 
   # Ctor.
   # @param [Symbol] operator Operator
@@ -167,9 +161,8 @@ class Factbase::Term < Factbase::TermBase
   # @param [Module] type The type to extend with
   # @param [Hash] args Attributes to set
   def redress!(type, **args)
-    extend type
-
-    args.each { |k, v| send(:instance_variable_set, :"@#{k}", v) }
+    extend(type)
+    args.each { |k, v| __send__(:instance_variable_set, :"@#{k}", v) }
     @operands.map do |op|
       if op.is_a?(Factbase::Term)
         op.redress!(type, **args)
@@ -195,7 +188,7 @@ class Factbase::Term < Factbase::TermBase
         maps
       end
     elsif respond_to?(m)
-      send(m, maps, fb, params)
+      __send__(m, maps, fb, params)
     else
       maps
     end
@@ -210,12 +203,12 @@ class Factbase::Term < Factbase::TermBase
     if @terms.key?(@op)
       @terms[@op].evaluate(fact, maps, fb)
     else
-      send(@op, fact, maps, fb)
+      __send__(@op, fact, maps, fb)
     end
   rescue NoMethodError => e
-    raise "Probably the term '#{@op}' is not defined at #{self}: #{e.message}"
+    raise(RuntimeError, "Probably the term '#{@op}' is not defined at #{self}: #{e.message}")
   rescue StandardError => e
-    raise "#{e.message.inspect} at #{self} at #{e.backtrace[0]}"
+    raise(RuntimeError, "#{e.message.inspect} at #{self} at #{e.backtrace[0]}")
   end
 
   # Simplify it if possible.
@@ -226,7 +219,7 @@ class Factbase::Term < Factbase::TermBase
     else
       m = "#{@op}_simplify"
       if respond_to?(m, true)
-        send(m)
+        __send__(m)
       else
         self
       end
@@ -262,11 +255,11 @@ class Factbase::Term < Factbase::TermBase
   def at(fact, maps, fb)
     assert_args(2)
     i = _values(0, fact, maps, fb)
-    raise "Too many values (#{i.size}) at first position, one expected" unless i.size == 1
+    raise(RuntimeError, "Too many values (#{i.size}) at first position, one expected") unless i.size == 1
     i = i[0]
-    return nil if i.nil?
+    return if i.nil?
     v = _values(1, fact, maps, fb)
-    return nil if v.nil?
+    return if v.nil?
     v[i]
   end
 end

data/lib/factbase/terms/agg.rb

@@ -23,13 +23,12 @@ class Factbase::Agg < Factbase::TermBase
     assert_args(2)
     selector = @operands[0]
     unless selector.is_a?(Factbase::Term) || selector.is_a?(Factbase::TermBase)
-      raise "A term is expected, but '#{selector}' provided"
+      raise(ArgumentError, "A term is expected, but '#{selector}' provided")
     end
     term = @operands[1]
     unless term.is_a?(Factbase::Term) || term.is_a?(Factbase::TermBase)
-      raise "A term is expected, but '#{term}' provided"
+      raise(ArgumentError, "A term is expected, but '#{term}' provided")
     end
-    subset = fb.query(selector, maps).each(fb, fact).to_a
-    term.evaluate(nil, subset, fb)
+    term.evaluate(nil, fb.query(selector, maps).each(fb, fact).to_a, fb)
   end
 end

data/lib/factbase/terms/arithmetic.rb

@@ -24,16 +24,16 @@ class Factbase::Arithmetic < Factbase::TermBase
   def evaluate(fact, maps, fb)
     assert_args(2)
     lefts = _values(0, fact, maps, fb)
-    return nil if lefts.nil?
-    raise 'Too many values at first position, one expected' unless lefts.size == 1
+    return if lefts.nil?
+    raise(ArgumentError, 'Too many values at first position, one expected') unless lefts.size == 1
     rights = _values(1, fact, maps, fb)
-    return nil if rights.nil?
-    raise 'Too many values at second position, one expected' unless rights.size == 1
+    return if rights.nil?
+    raise(ArgumentError, 'Too many values at second position, one expected') unless rights.size == 1
     v = lefts[0]
     r = rights[0]
     if v.is_a?(Time) && r.is_a?(String)
       (num, units) = r.split
-      num = num.to_i
+      num = Integer(num, 10)
       r =
         case units
         when 'seconds', 'second'
@@ -47,9 +47,9 @@ class Factbase::Arithmetic < Factbase::TermBase
         when 'weeks', 'week'
           num * 60 * 60 * 24 * 7
         else
-          raise "Unknown time unit '#{units}' in '#{r}"
+          raise(ArgumentError, "Unknown time unit '#{units}' in '#{r}")
         end
     end
-    v.send(@op, r)
+    v.__send__(@op, r)
   end
 end

data/lib/factbase/terms/as.rb

@@ -23,9 +23,9 @@ class Factbase::As < Factbase::TermBase
   def evaluate(fact, maps, fb)
     assert_args(2)
     a = @operands[0]
-    raise "A symbol is expected as first argument of 'as'" unless a.is_a?(Symbol)
+    raise(ArgumentError, "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) }
+    vv&.each { |v| fact.__send__(:"#{a}=", v) }
     true
   end
 end

data/lib/factbase/terms/assert.rb

@@ -26,24 +26,16 @@ class Factbase::Assert < Factbase::TermBase
     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"
+      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"
+      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
+    unless result.is_a?(Array) ? result.any? { |v| v && v != 0 } : (result && result != 0)
+      raise(StandardError, message)
+    end
     true
   end
 end

data/lib/factbase/terms/base.rb

@@ -33,15 +33,14 @@ class Factbase::TermBase
 
   def assert_args(num)
     c = @operands.size
-    raise "Too many (#{c}) operands for '#{@op}' (#{num} expected)" if c > num
-    raise "Too few (#{c}) operands for '#{@op}' (#{num} expected)" if c < num
+    raise(ArgumentError, "Too many (#{c}) operands for '#{@op}' (#{num} expected)") if c > num
+    raise(ArgumentError, "Too few (#{c}) operands for '#{@op}' (#{num} expected)") if c < num
   end
 
   def _by_symbol(pos, fact)
     o = @operands[pos]
-    raise "A symbol expected at ##{pos}, but '#{o}' (#{o.class}) provided" unless o.is_a?(Symbol)
-    k = o.to_s
-    fact[k]
+    raise(ArgumentError, "A symbol expected at ##{pos}, but '#{o}' (#{o.class}) provided") unless o.is_a?(Symbol)
+    fact[o.to_s]
   end
 
   # @return [Array|nil] Either array of values or NIL
@@ -59,9 +58,9 @@ class Factbase::TermBase
           [v]
         end
     end
-    raise 'Why not array?' unless v.is_a?(Array)
+    raise(ArgumentError, 'Why not array?') unless v.is_a?(Array)
     unless v.all? { |i| [Float, Integer, String, Time, TrueClass, FalseClass].any? { |t| i.is_a?(t) } }
-      raise 'Wrong type inside'
+      raise(ArgumentError, 'Wrong type inside')
     end
     v
   end

data/lib/factbase/terms/best.rb

@@ -10,7 +10,7 @@ class Factbase::Best
   end
 
   def evaluate(key, maps)
-    raise "A symbol is expected, but #{key} provided" unless key.is_a?(Symbol)
+    raise(ArgumentError, "A symbol is expected, but #{key} provided") unless key.is_a?(Symbol)
     best = nil
     maps.each do |m|
       vv = m[key.to_s]

data/lib/factbase/terms/boolean.rb

@@ -23,6 +23,6 @@ class Factbase::Boolean
     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 is expected, while #{val.class} received from #{@from}"
+    raise(ArgumentError, "Boolean is expected, while #{val.class} received from #{@from}")
   end
 end

data/lib/factbase/terms/compare.rb

@@ -43,9 +43,10 @@ class Factbase::Compare < Factbase::TermBase
   # @param [Object] right Right value
   # @return [Boolean] The result of the comparison
   def _compare(left, right)
-    left.send(@op, right)
+    left.__send__(@op, right)
   rescue ArgumentError => e
     raise(
+      RuntimeError,
       "Cannot compare #{left.inspect} (#{left.class}) " \
       "with #{right.inspect} (#{right.class}) using (compare #{@op}): #{e.message}"
     )

data/lib/factbase/terms/defn.rb

@@ -25,13 +25,15 @@ class Factbase::Defn < Factbase::TermBase
   def evaluate(_fact, _maps, _fb)
     assert_args(2)
     fn = @operands[0]
-    raise "A symbol expected as first argument of 'defn'" unless fn.is_a?(Symbol)
-    raise "Can't use '#{fn}' name as a term" if Factbase::Term.method_defined?(fn)
-    raise "Term '#{fn}' is already defined" if Factbase::Term.private_method_defined?(fn, false)
-    raise "The '#{fn}' is a bad name for a term" unless fn.match?(/^[a-z_]+$/)
-    e = "class Factbase::Term\nprivate\ndef #{fn}(fact, maps, fb)\n#{@operands[1]}\nend\nend"
+    raise(ArgumentError, "A symbol expected as first argument of 'defn'") unless fn.is_a?(Symbol)
+    raise(ArgumentError, "Can't use '#{fn}' name as a term") if Factbase::Term.method_defined?(fn)
+    raise(ArgumentError, "Term '#{fn}' is already defined") if Factbase::Term.private_method_defined?(fn, false)
+    raise(ArgumentError, "The '#{fn}' is a bad name for a term") unless fn.match?(/^[a-z_]+$/)
     # rubocop:disable Security/Eval
-    eval(e)
+    eval(
+      "class Factbase::Term\nprivate\ndef #{fn}(fact, maps, fb)\n#{@operands[1]}\nend\nend",
+      binding, __FILE__, __LINE__ - 1
+    )
     # rubocop:enable Security/Eval
     true
   end

data/lib/factbase/terms/empty.rb

@@ -24,7 +24,7 @@ class Factbase::Empty < Factbase::TermBase
     assert_args(1)
     term = @operands[0]
     unless term.is_a?(Factbase::Term) || term.is_a?(Factbase::TermBase)
-      raise "A term is expected, but '#{term}' provided"
+      raise(ArgumentError, "A term is expected, but '#{term}' provided")
     end
     # rubocop:disable Lint/UnreachableLoop
     fb.query(term, maps).each(fb, fact) do

data/lib/factbase/terms/first.rb

@@ -22,9 +22,9 @@ class Factbase::First < Factbase::TermBase
   def evaluate(_fact, maps, _fb)
     assert_args(1)
     k = @operands[0]
-    raise "A symbol is expected, but #{k} provided" unless k.is_a?(Symbol)
+    raise(ArgumentError, "A symbol is expected, but #{k} provided") unless k.is_a?(Symbol)
     first = maps[0]
-    return nil if first.nil?
+    return if first.nil?
     first[k.to_s]
   end
 end

data/lib/factbase/terms/head.rb

@@ -27,11 +27,11 @@ class Factbase::Head < Factbase::TermBase
   def predict(maps, fb, params)
     assert_args(2)
     max = @operands[0]
-    raise "An integer is expected as first argument of '#{@op}'" unless max.is_a?(Integer)
+    raise(ArgumentError, "An integer is expected as first argument of '#{@op}'") unless max.is_a?(Integer)
     term = @operands[1]
-    raise "A term is expected, but '#{term}' provided" unless term.is_a?(Factbase::Term)
+    raise(ArgumentError, "A term is expected, but '#{term}' provided") unless term.is_a?(Factbase::Term)
     fb.query(term, maps).each(fb, params).to_a
       .take(max)
-      .map { |m| m.all_properties.to_h { |k| [k, m[k]] } }
+      .map! { |m| m.all_properties.to_h { |k| [k, m[k]] } }
   end
 end

data/lib/factbase/terms/inverted.rb

@@ -26,9 +26,9 @@ class Factbase::Inverted < Factbase::TermBase
   def predict(maps, fb, params)
     assert_args(1)
     term = @operands[0]
-    raise "A term is expected, but '#{term}' provided" unless term.is_a?(Factbase::Term)
+    raise(ArgumentError, "A term is expected, but '#{term}' provided") unless term.is_a?(Factbase::Term)
     fb.query(term, maps).each(fb, params).to_a
       .reverse
-      .map { |m| m.all_properties.to_h { |k| [k, m[k]] } }
+      .map! { |m| m.all_properties.to_h { |k| [k, m[k]] } }
   end
 end

data/lib/factbase/terms/join.rb

@@ -23,18 +23,19 @@ class Factbase::Join < Factbase::TermBase
   def evaluate(fact, maps, fb)
     assert_args(2)
     jumps = @operands[0]
-    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 }
+    raise(ArgumentError, "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 is expected, but '#{term}' provided" unless term.is_a?(Factbase::Term)
+    raise(ArgumentError, "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|
         s[from]&.each do |v|
-          fact.send(:"#{to}=", v)
+          fact.__send__(:"#{to}=", v)
         end
       end
     end

data/lib/factbase/terms/matches.rb

@@ -26,10 +26,10 @@ class Factbase::Matches < Factbase::TermBase
     assert_args(2)
     str = _values(0, fact, maps, fb)
     return false if str.nil?
-    raise 'Exactly one string is expected' unless str.size == 1
+    raise(RuntimeError, '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 is expected' unless re.size == 1
+    raise(RuntimeError, 'Regexp is nil') if re.nil?
+    raise(RuntimeError, 'Exactly one regexp is expected') unless re.size == 1
     str[0].to_s.match?(regexp(re[0]))
   end
 
@@ -39,6 +39,6 @@ class Factbase::Matches < Factbase::TermBase
     key = pattern.to_s
     @regexps[key] ||= Regexp.new(key)
   rescue RegexpError => e
-    raise "Invalid regexp '#{key}': #{e.message}"
+    raise(RuntimeError, "Invalid regexp '#{key}': #{e.message}")
   end
 end