wongi-engine 0.4.0.pre.alpha5 → 0.4.0.pre.alpha7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 279bf4d4b1203e706faa3671e0e74ea20ee52d6236280fa8a7b878abe4df1aee
-  data.tar.gz: dc3a03595e87e552564c25aa47710cdb036c72a55dde73c00d913544398d6300
+  metadata.gz: 600fe3fc20d2cbecf1f59d7ad771eb387f97c9f00144089961dacb247c817475
+  data.tar.gz: 94d3cd24972fd5b6b67a1940804dc30d91c960e05ffe143889b5e0bb99e1fb84
 SHA512:
-  metadata.gz: 561a05b7b122d4c3e7ac3c0b4cccc80f3cb4a1e74620f69f32d2f17e66054f0ed83dbc196996d3e5cbf9b394740643dd3f5501d512b1014e638b34ab1385b06d
-  data.tar.gz: 3fd398dbda7b5c0b41dc100ed2c4dbe19aaad939561e3c1dbf30bae8d83ecb76ea3d3720005bfe75f5cb80c4f0a430869894d59c12e735653814367b4235b58c
+  metadata.gz: f233a3b5cd1a10ffab78742c5f14f319c24ff64e2d2683cf4e41e304287c832e818802e4224316e460909975b93658c0e13ecef5888101841002c054ea10689a
+  data.tar.gz: 11b1c635fa38aa4427dac9eba6807ad8294613a814ac98f588c0eee0eb7febec0542192e7113ea6b02bccffb25063e698e609a6fd1687a48cefbb5fb3a1b4d2f

data/.rubocop.yml

@@ -75,3 +75,12 @@ Style/OptionalBooleanParameter:
 
 Gemspec/RequiredRubyVersion:
   Enabled: false
+
+RSpec/MultipleExpectations:
+  Enabled: false
+
+RSpec/ContextWording:
+  Enabled: false
+
+RSpec/ExampleLength:
+  Enabled: false

data/lib/wongi-engine/alpha_index.rb

@@ -16,10 +16,9 @@ module Wongi::Engine
     def remove(wme)
       collection = collection_for_wme(wme)
       collection.delete(wme)
-      if collection.empty?
-        # release some memory
-        index.delete(hashed_key(wme))
-      end
+
+      # release some memory
+      index.delete(hashed_key(wme)) if collection.empty?
     end
 
     def collection_for_wme(wme)

data/lib/wongi-engine/beta/aggregate_node.rb

@@ -12,15 +12,9 @@ module Wongi::Engine
     end
 
     def make_partition_fn(partition)
-      return nil if partition.nil?
+      return nil if partition.empty?
 
-      if Template.variable?(partition)
-        ->(token) { token[partition] }
-      elsif partition.is_a?(Array) && partition.all? { Template.variable?(_1) }
-        ->(token) { token.values_at(*partition) }
-      else
-        partition
-      end
+      ->(token) { token.values_at(*partition) }
     end
 
     def make_aggregate_fn(agg)
@@ -53,12 +47,16 @@ module Wongi::Engine
     end
 
     def evaluate(child: nil)
-      groups = if partition
-        tokens.group_by(&partition).values
-      else
-        # just a single group of everything
-        [tokens]
-      end
+      return if tokens.empty?
+
+      groups =
+        if partition
+          tokens.group_by(&partition).values
+        else
+          # just a single group of everything
+          [tokens]
+        end
+
 
       groups.each do |tokens|
         aggregated = self.aggregate.call(tokens.map(&self.map))
@@ -67,9 +65,9 @@ module Wongi::Engine
         tokens.each do |token|
           # TODO: optimize this to work with a diff of actual changes
           beta_deactivate_children(token: token, children: children)
-          children.each do |beta|
-            beta.beta_activate(Token.new(beta, token, nil, assignment))
-          end
+        end
+        children.each do |beta|
+          beta.beta_activate(Token.new(beta, tokens, nil, assignment))
         end
       end
     end

data/lib/wongi-engine/beta/assignment_node.rb

@@ -20,7 +20,7 @@ module Wongi::Engine
       overlay.remove_token(token)
       children.each do |child|
         child.tokens.each do |t|
-          if t.parent == token
+          if t.child_of?(token)
             child.beta_deactivate t
             # token.destroy
           end

data/lib/wongi-engine/beta/beta_node.rb

@@ -51,7 +51,7 @@ module Wongi::Engine
 
     def beta_deactivate_children(token: nil, wme: nil, children: self.children)
       children.each do |child|
-        child.tokens.select { (token.nil? || _1.parent == token) && (wme.nil? || _1.wme == wme) }.each do |child_token|
+        child.tokens.select { (token.nil? || _1.child_of?(token)) && (wme.nil? || _1.wme == wme) }.each do |child_token|
           child.beta_deactivate(child_token)
         end
       end

data/lib/wongi-engine/beta/ncc_node.rb

@@ -36,7 +36,7 @@ module Wongi
       def ncc_deactivate(token)
         # p ncc_deactivate: {class: self.class, object_id:, token:}
         children.each do |beta|
-          beta.tokens.select { |t| t.parent == token }.each do |t|
+          beta.tokens.select { |t| t.child_of?(token) }.each do |t|
             beta.beta_deactivate t
           end
         end

data/lib/wongi-engine/beta/optional_node.rb

@@ -23,7 +23,7 @@ module Wongi
             if optional
               # we're going to change the optional state so the old ones need to be removed
               child.tokens.each do |ct|
-                child.beta_deactivate(ct) if ct.parent == token
+                child.beta_deactivate(ct) if ct.child_of?(token)
               end
             end
             child.beta_activate Token.new(child, token, wme, assignments)
@@ -43,7 +43,7 @@ module Wongi
 
             children.each do |child|
               child.tokens.each do |ct|
-                child.beta_deactivate(ct) if ct.parent == token
+                child.beta_deactivate(ct) if ct.child_of?(token)
               end
               child.beta_activate Token.new(child, token, nil, {})
             end

data/lib/wongi-engine/beta/root_node.rb

@@ -32,7 +32,7 @@ module Wongi::Engine
       overlay.remove_token(token)
 
       children.each do |child|
-        child.tokens.select { _1.parent == token }.each { child.beta_deactivate(_1) }
+        child.tokens.select { _1.child_of?(token) }.each { child.beta_deactivate(_1) }
       end
 
       nil

data/lib/wongi-engine/dsl/action/statement_generator.rb

@@ -42,14 +42,12 @@ module Wongi::Engine
           # asserting this WME would invalidate the match
           return false if token.node.is_a?(NegNode) && token.node.matches?(token, wme)
 
-          if token.parent && !considered_tokens.include?(token.parent)
-            tokens_to_consider.push(token.parent)
-          end
+          (token.parents - considered_tokens).each { |parent| tokens_to_consider.push(parent) }
+
+          next unless token.wme
 
-          if token.wme
-            overlay.generators(token.wme).each do |generator|
-              tokens_to_consider.push(generator.token) unless considered_tokens.include?(generator.token)
-            end
+          overlay.generators(token.wme).each do |generator|
+            tokens_to_consider.push(generator.token) unless considered_tokens.include?(generator.token)
           end
         end
 

data/lib/wongi-engine/dsl/clause/aggregate.rb

@@ -6,9 +6,10 @@ module Wongi::Engine
       def initialize(var, options = {})
         @var = var
         @over = options[:over]
-        @partition = options[:partition]
+        @partition = Array(options[:partition])
         @aggregate = options[:using]
         @map = options[:map]
+        raise "can only partition by variables" unless partition.all? { |p| Template.variable?(p) }
       end
 
       def compile(context)

data/lib/wongi-engine/network.rb

@@ -254,7 +254,7 @@ module Wongi::Engine
       end
     end
 
-    def select(s, p, o)
+    def select(s, p, o, &block)
       matching = current_overlay.select(s, p, o)
       if block_given?
         matching.each(&block)

data/lib/wongi-engine/overlay.rb

@@ -183,14 +183,16 @@ module Wongi::Engine
         case operation
         when :assert
           wme = find_ignoring_hidden(wme) || wme
+          visible = !find(wme).nil?
           add_wme(wme, **options)
-          rete.real_assert(wme)
+          rete.real_assert(wme) unless visible
         when :retract
           wme = find_ignoring_hidden(wme)
           return if wme.nil? # it's perhaps better to return quietly, because complicated cascades may delete a WME while we're going through the queue
 
+          visible = !find(wme).nil?
           remove_wme(wme, **options)
-          rete.real_retract(wme)
+          rete.real_retract(wme) if visible
         end
       end
     end

data/lib/wongi-engine/token.rb

@@ -1,26 +1,25 @@
+require 'set'
+
 module Wongi::Engine
   class Token
-    attr_reader :children, :wme, :node, :generated_wmes
-    attr_accessor :parent
+    attr_reader :wme, :node, :generated_wmes, :parents
 
-    def initialize(node, token, wme, assignments = {})
+    def initialize(node, parents, wme, assignments = {})
       @node = node
-      @parent = token
+      @parents = Set.new(Array(parents))
       @wme = wme
       @assignments = assignments
-      @children = []
       @deleted = false
       @ncc_results = []
       @generated_wmes = []
-      token.children << self if token
     end
 
     def ancestors
-      if parent
-        parent.ancestors.unshift parent
-      else
-        []
-      end
+      parents.flat_map(&:ancestors).uniq + parents.to_a
+    end
+
+    def child_of?(token)
+      parents.include?(token)
     end
 
     def subst(variable, value)
@@ -50,7 +49,10 @@ module Wongi::Engine
 
     # TODO: ignore assignments?
     def duplicate?(other)
-      parent.equal?(other.parent) && @wme.equal?(other.wme) && assignments == other.assignments
+      instance_of?(other.class) &&
+        parents == other.parents &&
+        wme == other.wme &&
+        assignments == other.assignments
     end
 
     def to_s
@@ -75,22 +77,18 @@ module Wongi::Engine
     end
 
     # for neg feedback loop protection
-    def generated?(wme)
-      return true if generated_wmes.any? { |w| w == wme }
-
-      children.any? { |t| t.generated? wme }
-    end
+    # def generated?(wme)
+    #   return true if generated_wmes.any? { |w| w == wme }
+    #
+    #   children.any? { |t| t.generated? wme }
+    # end
 
     protected
 
     def all_assignments
-      raise "Assignments is not a hash" unless @assignments.is_a?(Hash)
-
-      if @parent
-        @parent.assignments.merge @assignments
-      else
-        @assignments
-      end
+      parents.each_with_object({}) do |parent, acc|
+        acc.merge!(parent.assignments)
+      end.merge(@assignments)
     end
   end
 
@@ -99,7 +97,7 @@ module Wongi::Engine
       @parent = token
       @wme = wme
       @assignments = assignments
-      @children = []
+      # @children = []
       @neg_join_results = []
       @opt_join_results = []
       @ncc_results = []

data/lib/wongi-engine/version.rb

@@ -1,5 +1,5 @@
 module Wongi
   module Engine
-    VERSION = "0.4.0-alpha5".freeze
+    VERSION = "0.4.0-alpha7".freeze
   end
 end

data/lib/wongi-engine/wme.rb

@@ -10,10 +10,6 @@ module Wongi::Engine
       self.class.new(subject, predicate, object)
     end
 
-    def ==(other)
-      other && subject == other.subject && predicate == other.predicate && object == other.object
-    end
-
     # @param template Wongi::Engine::Template
     def =~(template)
       raise Wongi::Engine::Error, "Cannot match a WME against a #{template.class}" unless template.is_a?(Template)
@@ -30,14 +26,6 @@ module Wongi::Engine
       inspect
     end
 
-    def hash
-      @hash ||= [subject.hash, predicate.hash, object.hash].hash
-    end
-
-    def eql?(other)
-      subject.eql?(other.subject) && predicate.eql?(other.predicate) && object.eql?(other.object)
-    end
-
     protected
 
     def match_member(mine, theirs)

data/spec/aggregate_spec.rb

@@ -20,24 +20,21 @@ describe 'aggregate' do
 
       engine << [:apple, :weight, 5]
       expect(production.size).to be == 1
-      production.tokens.each do |token|
-        expect(token[:X]).to be == 5
-        expect(token[:Fruit]).to be == :apple
-      end
+      token = production.tokens.first
+      expect(token[:X]).to be == 5
+      expect(token[:Fruit]).to be == :apple
 
       engine << [:pea, :weight, 2]
-      expect(production.size).to be == 2
-      production.tokens.each do |token|
-        expect(token[:X]).to be == 2
-        expect(token[:Fruit]).to be == :pea
-      end
+      expect(production.size).to be == 1
+      token = production.tokens.first
+      expect(token[:X]).to be == 2
+      expect(token[:Fruit]).to be == :pea
 
       engine.retract [:pea, :weight, 2]
       expect(production.size).to be == 1
-      production.tokens.each do |token|
-        expect(token[:X]).to be == 5
-        expect(token[:Fruit]).to be == :apple
-      end
+      token = production.tokens.first
+      expect(token[:X]).to be == 5
+      expect(token[:Fruit]).to be == :apple
     end
   end
 
@@ -53,24 +50,21 @@ describe 'aggregate' do
 
       engine << [:pea, :weight, 2]
       expect(production.size).to be == 1
-      production.tokens.each do |token|
-        expect(token[:X]).to be == 2
-        expect(token[:Fruit]).to be == :pea
-      end
+      token = production.tokens.first
+      expect(token[:X]).to be == 2
+      expect(token[:Fruit]).to be == :pea
 
       engine << [:apple, :weight, 5]
-      expect(production.size).to be == 2
-      production.tokens.each do |token|
-        expect(token[:X]).to be == 5
-        expect(token[:Fruit]).to be == :apple
-      end
+      expect(production.size).to be == 1
+      token = production.tokens.first
+      expect(token[:X]).to be == 5
+      expect(token[:Fruit]).to be == :apple
 
       engine.retract [:apple, :weight, 5]
       expect(production.size).to be == 1
-      production.tokens.each do |token|
-        expect(token[:X]).to be == 2
-        expect(token[:Fruit]).to be == :pea
-      end
+      token = production.tokens.first
+      expect(token[:X]).to be == 2
+      expect(token[:Fruit]).to be == :pea
     end
   end
 
@@ -85,27 +79,23 @@ describe 'aggregate' do
 
       engine << [:pea, :weight, 1]
       expect(production.size).to be == 1
-      production.tokens.each do |token|
-        expect(token[:Count]).to be == 1
-      end
+      token = production.tokens.first
+      expect(token[:Count]).to be == 1
 
       engine << [:apple, :weight, 5]
-      expect(production.size).to be == 2
-      production.tokens.each do |token|
-        expect(token[:Count]).to be == 2
-      end
+      expect(production.size).to be == 1
+      token = production.tokens.first
+      expect(token[:Count]).to be == 2
 
       engine << [:watermelon, :weight, 15]
-      expect(production.size).to be == 3
-      production.tokens.each do |token|
-        expect(token[:Count]).to be == 3
-      end
+      expect(production.size).to be == 1
+      token = production.tokens.first
+      expect(token[:Count]).to be == 3
 
       engine.retract [:apple, :weight, 5]
-      expect(production.size).to be == 2
-      production.tokens.each do |token|
-        expect(token[:Count]).to be == 2
-      end
+      expect(production.size).to be == 1
+      token = production.tokens.first
+      expect(token[:Count]).to be == 2
     end
 
     it 'works with a post-filter' do
@@ -124,10 +114,9 @@ describe 'aggregate' do
       expect(production.size).to be == 0
 
       engine << [:watermelon, :weight, 15]
-      expect(production.size).to be == 3
-      production.tokens.each do |token|
-        expect(token[:Count]).to be == 3
-      end
+      expect(production.size).to be == 1
+      token = production.tokens.first
+      expect(token[:Count]).to be == 3
 
       engine.retract [:apple, :weight, 5]
       expect(production.size).to be == 0
@@ -148,7 +137,7 @@ describe 'aggregate' do
       engine << [:factor, 12, 3]
       engine << [:factor, 12, 4]
 
-      expect(production).to have(4).tokens
+      expect(production).to have(2).tokens
       production.tokens.each do |token|
         expect(token[:Product]).to be_a(Integer)
         expect(token[:Product]).to eq(token[:Number])
@@ -170,11 +159,55 @@ describe 'aggregate' do
       engine << [:factor, 12, 3]
       engine << [:factor, 12, 4]
 
-      expect(production).to have(4).tokens
+      expect(production).to have(2).tokens
       production.tokens.each do |token|
         expect(token[:Product]).to be_a(Integer)
         expect(token[:Product]).to eq(token[:Number])
       end
     end
   end
+
+  it 'propagates a single token' do
+    engine << rule {
+      forall {
+        has :Item, :price_group, :Group
+        has :Group, :name, :Name
+        has :Group, :base_price, :Price
+        max :MaxPrice, over: :Price, partition: %i[Item Name]
+        # equal :Price, :MaxPrice # -- this is necessary for this to work without token converging
+      }
+      make {
+        gen :Group, :price, :MaxPrice
+      }
+    }
+
+    engine << rule("sum") {
+      forall {
+        has :Item, :price_group, :Group
+        has :Group, :price, :Price
+        sum :TotalPrice, over: :Price, partition: :Item
+      }
+      make {
+        gen :Item, :price, :TotalPrice
+      }
+    }
+
+    material1 = Object.new
+    engine << [:toy, :price_group, material1]
+    engine << [material1, :name, :material]
+    engine << [material1, :base_price, 100]
+
+    material2 = Object.new
+    engine << [:toy, :price_group, material2]
+    engine << [material2, :name, :material]
+    engine << [material2, :base_price, 200]
+
+    packaging = Object.new
+    engine << [:toy, :price_group, packaging]
+    engine << [packaging, :name, :packaging]
+    engine << [packaging, :base_price, 20]
+
+    total_price = engine.select(:toy, :price, :_).first
+    expect(total_price.object).to eq(220)
+  end
 end

data/spec/dataset_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Wongi::Engine::Network do
   include Wongi::Engine::DSL
   it 'exposes compiled productions' do
-    ds = Wongi::Engine::Network.new
+    ds = Wongi::Engine.create
 
     ds << rule('test-rule') {
       forall {

data/spec/greater_than_equality_test_spec.rb

@@ -2,29 +2,23 @@
 
 require 'spec_helper'
 
-describe 'Greater Than Or Equal test' do
+describe Wongi::Engine::GreaterThanOrEqualTest do
   include Wongi::Engine::DSL
   let(:engine) { Wongi::Engine.create }
 
-  attr_reader :production
-
-  def test_rule(&block)
-    @production = (engine << rule('test-rule', &block))
-  end
-
   it 'interacts with optional node correctly' do
     # before the fix, filters would try to piggy-back on optional templates
 
-    test_rule do
-      forall do
+    production = engine << rule {
+      forall {
         has :Number, :assign_check, :_
         gte :Number, 6
-      end
-    end
+      }
+    }
 
     engine << [6, :assign_check, nil]
     engine << [7, :assign_check, nil]
     engine << [5, :assign_check, nil]
-    expect(@production.size).to eq(2)
+    expect(production.size).to eq(2)
   end
 end

data/spec/high_level_spec.rb

@@ -10,7 +10,7 @@ class << self
   }
 end
 
-describe 'the engine' do
+describe Wongi::Engine::Network do
   include Wongi::Engine::DSL
   let(:engine) { Wongi::Engine.create }
 

data/spec/less_test_spec.rb

@@ -1,19 +1,13 @@
 require 'spec_helper'
 
-describe "LESS test" do
+describe Wongi::Engine::LessThanTest do
   include Wongi::Engine::DSL
   let(:engine) { Wongi::Engine.create }
 
-  attr_reader :production
-
-  def test_rule(&block)
-    @production = (engine << rule('test-rule', &block))
-  end
-
   it "interacts with optional node correctly" do
     # before the fix, filters would try to piggy-back on optional templates
 
-    test_rule {
+    production = engine << rule {
       forall {
         maybe "Z", "Z", "Z"
         less 6, 4 # this should fail
@@ -26,6 +20,6 @@ describe "LESS test" do
 
     engine << %w[A B C]
 
-    expect(@production.size).to eq(0)
+    expect(production.size).to eq(0)
   end
 end

data/spec/less_than_equality_test_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe 'Less Than Or Equal test' do
+describe Wongi::Engine::LessThanOrEqualTest do
   include Wongi::Engine::DSL
   let(:engine) { Wongi::Engine.create }
 

data/spec/network_spec.rb

@@ -3,62 +3,60 @@ require 'spec_helper'
 describe Wongi::Engine::Network do
   include Wongi::Engine::DSL
 
-  subject { engine }
-
   let(:engine) { Wongi::Engine.create }
 
   it 'asserts facts' do
-    subject << [1, 2, 3]
-    expect(subject.select(:_, 2, :_)).to have(1).item
+    engine << [1, 2, 3]
+    expect(engine.select(:_, 2, :_)).to have(1).item
   end
 
   it 'retracts facts' do
-    subject << [1, 2, 3]
-    subject.retract [1, 2, 3]
-    expect(subject.select(:_, 2, :_).count).to eq(0)
+    engine << [1, 2, 3]
+    engine.retract [1, 2, 3]
+    expect(engine.select(:_, 2, :_).count).to eq(0)
   end
 
   it 'asserted facts end up in productions' do
-    prod = subject << rule { forall { has :X, 2, :Z } }
-    subject << [1, 2, 3]
+    prod = engine << rule { forall { has :X, 2, :Z } }
+    engine << [1, 2, 3]
     expect(prod).to have(1).tokens
   end
 
   it 'rules can be removed from engine' do
-    subject << [1, 2, 3]
-    subject << [4, 5, 6]
+    engine << [1, 2, 3]
+    engine << [4, 5, 6]
 
-    prod1 = subject << rule { forall { has :X, 2, :Z } }
-    prod2 = subject << rule { forall { has :X, 5, :Z } }
+    prod1 = engine << rule { forall { has :X, 2, :Z } }
+    prod2 = engine << rule { forall { has :X, 5, :Z } }
 
     expect(prod1).to have(1).tokens
     expect(prod2).to have(1).tokens
 
-    subject.remove_production(prod1)
+    engine.remove_production(prod1)
 
     expect(prod1).to have(0).tokens
     expect(prod2).to have(1).tokens
   end
 
   it 'new rules can be added to engine after a rule has been been removed' do
-    subject << [1, 2, 3]
-    subject << [4, 5, 6]
+    engine << [1, 2, 3]
+    engine << [4, 5, 6]
 
-    prod1 = subject << rule { forall { has :X, 2, :Z } }
+    prod1 = engine << rule { forall { has :X, 2, :Z } }
 
     expect(prod1).to have(1).tokens
 
-    subject.remove_production(prod1)
+    engine.remove_production(prod1)
     expect(prod1).to have(0).tokens
 
-    prod2 = subject << rule { forall { has :X, 5, :Z } }
+    prod2 = engine << rule { forall { has :X, 5, :Z } }
     expect(prod2).to have(1).tokens
   end
 
   it 'retracted facts are removed from productions' do
-    prod = subject << rule { forall { has :X, 2, :Z } }
-    subject << [1, 2, 3]
-    subject.retract [1, 2, 3]
+    prod = engine << rule { forall { has :X, 2, :Z } }
+    engine << [1, 2, 3]
+    engine.retract [1, 2, 3]
     expect(prod).to have(0).tokens
   end
 
@@ -66,17 +64,17 @@ describe Wongi::Engine::Network do
     activated_z = nil
     deactivated_z = nil
 
-    subject << rule {
+    engine << rule {
       forall { has :X, 2, :Z }
       make {
         action activate: ->(token) { activated_z = token[:Z] },
                deactivate: ->(token) { deactivated_z = token[:Z] }
       }
     }
-    subject << [1, 2, 3]
+    engine << [1, 2, 3]
     expect(activated_z).to be == 3
 
-    subject.retract [1, 2, 3]
+    engine.retract [1, 2, 3]
     expect(deactivated_z).to be == 3
   end
 

data/spec/ruleset_spec.rb

@@ -2,44 +2,44 @@ require 'spec_helper'
 
 describe Wongi::Engine::Ruleset do
   before do
-    Wongi::Engine::Ruleset.reset
+    described_class.reset
   end
 
   context 'initially' do
     it 'has no rules' do
-      expect(Wongi::Engine::Ruleset.rulesets).to be_empty
+      expect(described_class.rulesets).to be_empty
     end
   end
 
   context 'when creating' do
     it 'does not register itself when not given a name' do
-      ruleset = Wongi::Engine::Ruleset.new
+      ruleset = described_class.new
       expect(ruleset.name).to be_nil
-      expect(Wongi::Engine::Ruleset.rulesets).to be_empty
+      expect(described_class.rulesets).to be_empty
     end
 
     it 'has a name' do
-      ruleset = Wongi::Engine::Ruleset.new 'testing-ruleset'
+      ruleset = described_class.new 'testing-ruleset'
       expect(ruleset.name).to be == 'testing-ruleset'
     end
 
     it 'registers itself when given a name' do
-      ruleset = Wongi::Engine::Ruleset.new 'testing-ruleset'
-      expect(Wongi::Engine::Ruleset.rulesets).not_to be_empty
-      expect(Wongi::Engine::Ruleset[ruleset.name]).to be == ruleset
+      ruleset = described_class.new 'testing-ruleset'
+      expect(described_class.rulesets).not_to be_empty
+      expect(described_class[ruleset.name]).to be == ruleset
     end
   end
 
   it 'is able to clear registered rulesets' do
-    _ = Wongi::Engine::Ruleset.new 'testing-ruleset'
-    Wongi::Engine::Ruleset.reset
-    expect(Wongi::Engine::Ruleset.rulesets).to be_empty
+    _ = described_class.new 'testing-ruleset'
+    described_class.reset
+    expect(described_class.rulesets).to be_empty
   end
 
   it 'installs creating rules into a rete' do
     rete = double 'rete'
 
-    ruleset = Wongi::Engine::Ruleset.new
+    ruleset = described_class.new
     rule = ruleset.rule('test-rule') {}
 
     expect(rete).to receive(:<<).with(rule).once

data/spec/wme_spec.rb

@@ -9,36 +9,36 @@ describe Wongi::Engine::WME do
   #   rete
   # end
 
-  subject {
-    Wongi::Engine::WME.new "a", "b", "c"
+  let(:wme) {
+    described_class.new "a", "b", "c"
   }
 
   context 'a new WME' do
     it 'initializes and expose members' do
-      expect(subject.subject).to be == "a"
-      expect(subject.predicate).to be == "b"
-      expect(subject.object).to be == "c"
+      expect(wme.subject).to be == "a"
+      expect(wme.predicate).to be == "b"
+      expect(wme.object).to be == "c"
     end
   end
 
   it 'compares instances' do
-    wme1 = Wongi::Engine::WME.new "a", "b", "c"
-    wme2 = Wongi::Engine::WME.new "a", "b", "c"
-    wme3 = Wongi::Engine::WME.new "a", "b", "d"
+    wme1 = described_class.new "a", "b", "c"
+    wme2 = described_class.new "a", "b", "c"
+    wme3 = described_class.new "a", "b", "d"
 
     expect(wme1).to be == wme2
     expect(wme1).not_to be == wme3
   end
 
   it 'does not match against non-templates' do
-    expect { subject =~ [1, 2, 3] }.to raise_error(Wongi::Engine::Error)
+    expect { wme =~ [1, 2, 3] }.to raise_error(Wongi::Engine::Error)
   end
 
   it 'matches against templates' do
     t1 = Wongi::Engine::Template.new "a", :_, :_
     t2 = Wongi::Engine::Template.new "b", :_, :_
 
-    expect(subject).to be =~ t1
-    expect(subject).not_to be =~ t2
+    expect(wme).to be =~ t1
+    expect(wme).not_to be =~ t2
   end
 end

data/wongi-engine.gemspec

@@ -5,26 +5,29 @@ module GemHelper
   def self.git?
     File.exist?('.git')
   end
-
-  def self.hg?
-    File.exist?('.hg')
-  end
 end
 
 Gem::Specification.new do |gem|
-  gem.authors       = ['Valeri Sokolov']
-  gem.email         = ['ulfurinn@ulfurinn.net']
-  gem.description   = 'A rule engine.'
-  gem.summary       = 'A forward-chaining rule engine in pure Ruby.'
-  gem.homepage      = 'https://github.com/ulfurinn/wongi-engine'
-  gem.licenses      = %w[MIT]
+  gem.authors = ['Valeri Sokolov']
+  gem.email   = ['ulfurinn@ulfurinn.net']
+
+  gem.description = 'A forward-chaining rule engine in pure Ruby.'
+  gem.summary     = 'A forward-chaining rule engine in pure Ruby.'
+
+  gem.required_ruby_version = '>= 2.7.0'
+
+  gem.licenses = %w[MIT]
+
+  gem.homepage = 'https://github.com/ulfurinn/wongi-engine'
+  gem.metadata = {
+    "documentation_uri" => 'https://ulfurinn.github.io/wongi-engine/',
+    "rubygems_mfa_required" => 'true',
+  }
 
   gem.files = if GemHelper.git?
                 `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
-              elsif GemHelper.hg?
-                `hg st -cn`.split($OUTPUT_RECORD_SEPARATOR)
               else
-                raise 'cannot enumerate files: not a git or hg repository'
+                raise 'cannot enumerate files: not a git repository'
               end
   gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.name          = 'wongi-engine'
@@ -36,5 +39,4 @@ Gem::Specification.new do |gem|
   # gem.add_development_dependency 'pry-byebug', '~> 2.0'
   gem.add_development_dependency 'rspec', '~> 3.1'
   gem.add_development_dependency 'rspec-collection_matchers', '~> 1.1'
-  gem.metadata['rubygems_mfa_required'] = 'true'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wongi-engine
 version: !ruby/object:Gem::Version
-  version: 0.4.0.pre.alpha5
+  version: 0.4.0.pre.alpha7
 platform: ruby
 authors:
 - Valeri Sokolov
@@ -66,7 +66,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
-description: A rule engine.
+description: A forward-chaining rule engine in pure Ruby.
 email:
 - ulfurinn@ulfurinn.net
 executables: []
@@ -180,6 +180,7 @@ homepage: https://github.com/ulfurinn/wongi-engine
 licenses:
 - MIT
 metadata:
+  documentation_uri: https://ulfurinn.github.io/wongi-engine/
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
@@ -189,7 +190,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">"