factbase 0.19.10 → 0.19.12

data/lib/factbase/indexed/indexed_and.rb

@@ -11,12 +11,12 @@ class Factbase::IndexedAnd
   end
 
   def predict(maps, fb, params)
-    return nil if @idx.nil?
+    return if @idx.nil?
     key = [maps.object_id, @term.operands.first, @term.op]
     r = nil
     if @term.operands.all? { |o| o.op == :eq } && @term.operands.size > 1 \
       && @term.operands.all? { |o| o.operands.first.is_a?(Symbol) && _scalar?(o.operands[1]) }
-      props = @term.operands.map { |o| o.operands.first }.sort
+      props = @term.operands.map { |o| o.operands.first }.sort!
       key = [maps.object_id, props, :multi_and_eq]
       entry = @idx[key]
       maps_array = maps.to_a
@@ -45,19 +45,24 @@ class Factbase::IndexedAnd
       j = tuples.flat_map { |t| entry[:index][t] || [] }.uniq(&:object_id)
       r = maps.respond_to?(:repack) ? maps.repack(j) : j
     else
+      fail = false
       @term.operands.each do |o|
         n = o.predict(maps, fb, params)
-        break if n.nil?
+        if n.nil?
+          fail = true
+          break
+        end
         if r.nil?
           r = n
-        elsif n.size < r.size * 8 # to skip some obvious matchings
+        elsif n.size < r.size * 8
           small, large = n.size < r.size ? [n.to_a, r.to_a] : [r.to_a, n.to_a]
           ids = Set.new(small.map(&:object_id))
           r = large.select { |f| ids.include?(f.object_id) }
         end
-        break if r.size < maps.size / 32 # it's already small enough
-        break if r.size < 128 # it's obviously already small enough
+        break if r.size < maps.size / 32
+        break if r.size < 128
       end
+      return if fail
     end
     r
   end
@@ -69,19 +74,8 @@ class Factbase::IndexedAnd
   end
 
   def _all_tuples(fact, props)
-    prop = props.first.to_s
-    tuples = []
-    tuples += (fact[prop] || []).zip
-    if props.size > 1
-      tails = _all_tuples(fact, props[1..])
-      ext = []
-      tuples.each do |t|
-        tails.each do |tail|
-          ext << (t + tail)
-        end
-      end
-      tuples = ext
-    end
-    tuples
+    values = props.map { |p| fact[p.to_s] || [] }
+    return [] if values.any?(&:empty?)
+    values[0].product(*values[1..])
   end
 end

data/lib/factbase/indexed/indexed_eq.rb

@@ -3,7 +3,11 @@
 # SPDX-FileCopyrightText: Copyright (c) 2024-2026 Yegor Bugayenko
 # SPDX-License-Identifier: MIT
 
-# Indexed term 'eq'.
+# Indexed term 'eq' that uses the hash-based inverted index for fast equality lookups.
+#
+# Author:: Yegor Bugayenko (yegor256@gmail.com)
+# Copyright:: Copyright (c) 2024-2026 Yegor Bugayenko
+# License:: MIT
 class Factbase::IndexedEq
   def initialize(term, idx)
     @term = term

data/lib/factbase/indexed/indexed_fact.rb

@@ -26,11 +26,8 @@ class Factbase::IndexedFact
     @origin.to_s
   end
 
-  # When a method is missing, this method is called.
   others do |*args|
-    # Only clear index when modifying properties on existing (non-fresh) facts
-    # Fresh facts are not in the index yet, so modifications don't affect it
     @idx.clear if args[0].to_s.end_with?('=') && !@fresh.include?(object_id)
-    @origin.send(*args)
+    @origin.__send__(*args)
   end
 end

data/lib/factbase/indexed/indexed_factbase.rb

@@ -23,9 +23,9 @@ class Factbase::IndexedFactbase
   # @param [Hash] idx Index to use
   # @param [Set] fresh The set of IDs of newly inserted facts
   def initialize(origin, idx = {}, fresh = Set.new)
-    raise 'Wrong type of original' unless origin.respond_to?(:query)
+    raise(ArgumentError, 'Wrong type of original') unless origin.respond_to?(:query)
     @origin = origin
-    raise 'Wrong type of index' unless idx.is_a?(Hash)
+    raise(ArgumentError, 'Wrong type of index') unless idx.is_a?(Hash)
     @idx = idx
     @fresh = fresh
   end
@@ -64,7 +64,7 @@ class Factbase::IndexedFactbase
     inner_idx = {}
     result =
       @origin.txn do |fbt|
-        yield Factbase::IndexedFactbase.new(fbt, inner_idx, @fresh)
+        yield(Factbase::IndexedFactbase.new(fbt, inner_idx, @fresh))
       end
     @idx.clear if result.deleted.positive? || result.added.positive?
     @fresh.clear
@@ -100,7 +100,7 @@ class Factbase::IndexedFactbase
   #
   # @param [String] bytes Binary string to import
   def import(bytes)
-    raise 'Empty input, cannot load a factbase' if bytes.empty?
+    raise(StandardError, 'Empty input, cannot load a factbase') if bytes.empty?
     data = Marshal.load(bytes)
     if data.is_a?(Hash) && data.key?(:maps)
       @origin.import(data[:maps])

data/lib/factbase/indexed/indexed_gt.rb

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

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