wongi-engine 0.4.0.pre.alpha9 → 0.4.0.pre.alpha11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b8990e295e71589c0de4e5ab8ab947e4a88d6de25df75d15ea219532cd923e7
-  data.tar.gz: ba314dbc0885f56c74b876d00f3b903836931a0b959b23708375c778692801c9
+  metadata.gz: c6618cdaae22d90fec75bb11bbfeb27477d9aca0661d0de91ab04ce3b434ce6e
+  data.tar.gz: c9973d3a202faa0882653e99a3db546af9b02f6d1e09af075e4749681903743b
 SHA512:
-  metadata.gz: 34593896193fc9eb110f04794c2f33ae43f53e6061bf557e16320f980646999573002e186f4ef591388b16692419eb478aaab80e03250f500a64c407fc227333
-  data.tar.gz: 97a14c3519ca53e3cbc665ff9d682ff41cc8b20a3d3e4f6de238c67c4a9ad6ac4d31dc90c605b83c205f5e469f8394a8d501377ea476c484291542fa6bd1c371
+  metadata.gz: 2ec734eba8278f9ed3b8571b67a5e7449c4d172143673953d568bc4299383dc60579c295457010a3e9160de5698ecd529713dad80940751fce6c8b599d05dc91
+  data.tar.gz: ead1a3405786c7be13882c24ce8457ff31efa003bd9a84722073ff543ddff028b201c5d769756a2fadadfa84bbf0d5289db810f4e06d574c6b5960cb3a55302e

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

@@ -57,17 +57,17 @@ module Wongi::Engine
           [tokens]
         end
 
-
       groups.each do |tokens|
-        aggregated = self.aggregate.call(tokens.map(&self.map))
+        aggregated = aggregate.call(tokens.map(&map))
         assignment = { var => aggregated }
         children = child ? [child] : self.children
-        tokens.each do |token|
-          # TODO: optimize this to work with a diff of actual changes
-          beta_deactivate_children(token: token, children: children)
-        end
         children.each do |beta|
-          beta.beta_activate(Token.new(beta, tokens, nil, assignment))
+          new_token = Token.new(beta, tokens, nil, assignment)
+          # nothing changed, skip useless traversal
+          next if beta.tokens.find { _1.duplicate?(new_token) }
+
+          beta.tokens.select { |child| tokens.any? { child.child_of?(_1) } }.each { beta.beta_deactivate(_1) }
+          beta.beta_activate(new_token)
         end
       end
     end

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

@@ -58,7 +58,8 @@ module Wongi::Engine
     end
 
     private def select_wmes(template)
-      rete.current_overlay.select(template)
+      # capture the enumerator
+      rete.current_overlay.select(template).to_a
     end
 
     private def specialize(template, tests, token)

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

@@ -3,8 +3,6 @@ require "set"
 module Wongi::Engine
   module DSL::Action
     class StatementGenerator < BaseAction
-      GeneratorOrigin = Struct.new(:token, :action)
-
       attr_reader :template
       private :template
 
@@ -23,13 +21,13 @@ module Wongi::Engine
         production.tracer.trace(action: self, wme: wme) if production.tracer
 
         if should_assert?(wme, token)
-          origin = GeneratorOrigin.new(token, self)
-          token.generated_wmes << wme
-          overlay.assert(wme, generator: origin)
+          overlay.assert(wme, generator: token)
         end
       end
 
       private def should_assert?(wme, token)
+        return true if rete.bypass_consistency_checks?
+
         considered_tokens = Set.new
         tokens_to_consider = [token]
         until tokens_to_consider.empty?
@@ -37,34 +35,30 @@ module Wongi::Engine
           considered_tokens.add(token)
 
           # self-affirming reasoning
-          return false if token.wme == wme
+          if token.wme == wme
+            # puts "detected self-affirming"
+            return false
+          end
 
           # asserting this WME would invalidate the match
           # TODO: clean up
-          return false if token.node.is_a?(NegNode) && wme =~ token.node.alpha.template && token.node.matches?(token, wme) # how much is actually necessary?
+          if token.node.is_a?(NegNode) && wme =~ token.node.alpha.template && token.node.matches?(token, wme) # how much is actually necessary?
+            # puts "detected self-negating"
+            return false
+          end
 
           token.parents.each { |parent| tokens_to_consider.push(parent) unless considered_tokens.include?(parent) }
 
           next unless token.wme
 
-          overlay.generators(token.wme).each do |generator|
-            tokens_to_consider.push(generator.token) unless considered_tokens.include?(generator.token)
+          overlay.generators(token.wme).each do |generating_token|
+            tokens_to_consider.push(generating_token) unless considered_tokens.include?(generating_token)
           end
         end
 
         # we could not prove that the new WME should not be asserted
         true
       end
-
-      def deexecute(token)
-        # p deexecute: {token:}
-        origin = GeneratorOrigin.new(token, self)
-
-        generated = token.generated_wmes.dup # select { overlay.generators(_1).include?(origin) }
-        generated.each do |wme|
-          overlay.retract wme, generator: origin
-        end
-      end
     end
   end
 end

data/lib/wongi-engine/generator_tracker.rb

@@ -0,0 +1,32 @@
+module Wongi::Engine
+  class GeneratorTracker
+    def initialize
+      @by_wme = Hash.new { |h, k| h[k] = Set.new }
+      @by_token = Hash.new { |h, k| h[k] = Set.new }
+    end
+
+    def add(wme, token)
+      @by_wme[wme].add(token)
+      @by_token[token.object_id].add(wme)
+    end
+
+    def for_wme(wme)
+      @by_wme.has_key?(wme) ? @by_wme[wme] : Set.new
+    end
+
+    def for_token(token)
+      @by_token.has_key?(token.object_id) ? @by_token[token.object_id] : Set.new
+    end
+
+    def remove_token(token)
+      wmes = for_token(token)
+      @by_token.delete(token.object_id)
+      wmes.each do |wme|
+        next unless @by_wme.key?(wme)
+
+        @by_wme[wme].delete(token)
+        @by_wme.delete(wme) if @by_wme[wme].empty?
+      end
+    end
+  end
+end

data/lib/wongi-engine/join_results.rb

@@ -0,0 +1,80 @@
+module Wongi::Engine
+  class JoinResults
+    attr_reader :by_wme, :by_token, :hidden
+    private :by_wme, :by_token
+    private :hidden
+    def initialize
+      @by_wme = Hash.new { |h, k| h[k] = {} }
+      @by_token = Hash.new { |h, k| h[k] = {} }
+      @hidden = {}
+    end
+
+    def for(wme: nil, token: nil)
+      if wme
+        by_wme.key?(wme) ? by_wme[wme].keys : []
+      elsif token
+        by_token.key?(token.object_id) ? by_token[token.object_id].keys : []
+      else
+        []
+      end
+    end
+
+    def has?(jr)
+      by_wme.key?(jr.wme) && by_wme[jr.wme].key?(jr)
+    end
+
+    def hidden?(jr)
+      hidden.key?(jr)
+    end
+
+    def add(jr)
+      if hidden.key?(jr)
+        hidden.delete(jr)
+      else
+        by_wme[jr.wme][jr] = true
+        by_token[jr.token.object_id][jr] = true
+      end
+    end
+
+    def remove(jr)
+      unless has?(jr)
+        hide(jr)
+        return
+      end
+
+      if by_wme.key?(jr.wme)
+        by_wme[jr.wme].delete(jr)
+        if by_wme[jr.wme].empty?
+          by_wme.delete(jr.wme)
+        end
+      end
+
+      if by_token.key?(jr.token.object_id)
+        by_token[jr.token.object_id].delete(jr)
+        if by_token[jr.token.object_id].empty?
+          by_token.delete(jr.token.object_id)
+        end
+      end
+    end
+
+    def hide(jr)
+      hidden[jr] = true
+    end
+
+    def remove_token(token)
+      return unless by_token.key?(token.object_id)
+
+      by_token[token.object_id].keys.each do |jr|
+        remove(jr)
+      end
+    end
+
+    def remove_wme(wme)
+      return unless by_wme.key?(wme)
+
+      by_wme[wme].keys do |jr|
+        remove(jr)
+      end
+    end
+  end
+end

data/lib/wongi-engine/network.rb

@@ -3,9 +3,12 @@ require 'wongi-engine/network/debug'
 
 module Wongi::Engine
   class Network
+    include CoreExt
     attr_accessor :alpha_top, :beta_top, :queries, :results, :alpha_hash
     attr_reader :productions, :overlays
 
+    attr_predicate :bypass_consistency_checks
+
     include NetworkParts::Collectable
     private :overlays
     private :alpha_hash, :alpha_hash=
@@ -67,7 +70,6 @@ module Wongi::Engine
       block.call(child)
     ensure
       remove_overlay(child)
-      child.dispose!
     end
 
     def alphas
@@ -203,9 +205,8 @@ module Wongi::Engine
       compile_alpha Template.new(s, p, o)
     end
 
-    # TODO: pick an alpha with fewer candidates to go through
     def initial_fill(alpha)
-      default_overlay.select(:_, :_, :_).each do |wme|
+      default_overlay.select(:_, :_, :_).to_a.each do |wme|
         alpha.activate wme if wme =~ alpha.template
       end
     end
@@ -254,16 +255,11 @@ module Wongi::Engine
     end
 
     def select(s, p, o, &block)
-      matching = current_overlay.select(s, p, o)
-      if block_given?
-        matching.each(&block)
-      else
-        matching.each
-      end
+      current_overlay.select(s, p, o, &block)
     end
 
     def find(s, p, o)
-      current_overlay.select(s, p, o).first
+      select(s, p, o).first
     end
 
     protected

data/lib/wongi-engine/overlay.rb

@@ -1,92 +1,13 @@
 module Wongi::Engine
   class Overlay
-    class JoinResults
-      attr_reader :by_wme, :by_token, :hidden
-      private :by_wme, :by_token
-      private :hidden
-      def initialize
-        @by_wme = Hash.new { |h, k| h[k] = {} }
-        @by_token = Hash.new { |h, k| h[k] = {} }
-        @hidden = {}
-      end
-
-      def for(wme: nil, token: nil)
-        if wme
-          by_wme.key?(wme) ? by_wme[wme].keys : []
-        elsif token
-          by_token.key?(token.object_id) ? by_token[token.object_id].keys : []
-        else
-          []
-        end
-      end
-
-      def has?(jr)
-        by_wme.key?(jr.wme) && by_wme[jr.wme].key?(jr)
-      end
-
-      def hidden?(jr)
-        hidden.key?(jr)
-      end
 
-      def add(jr)
-        if hidden.key?(jr)
-          hidden.delete(jr)
-        else
-          by_wme[jr.wme][jr] = true
-          by_token[jr.token.object_id][jr] = true
-        end
-      end
-
-      def remove(jr)
-        unless has?(jr)
-          hide(jr)
-          return
-        end
-
-        if by_wme.key?(jr.wme)
-          by_wme[jr.wme].delete(jr)
-          if by_wme[jr.wme].empty?
-            by_wme.delete(jr.wme)
-          end
-        end
-
-        if by_token.key?(jr.token.object_id)
-          by_token[jr.token.object_id].delete(jr)
-          if by_token[jr.token.object_id].empty?
-            by_token.delete(jr.token.object_id)
-          end
-        end
-      end
-
-      def hide(jr)
-        hidden[jr] = true
-      end
-
-      def remove_token(token)
-        return unless by_token.key?(token.object_id)
-
-        by_token[token.object_id].keys.each do |jr|
-          remove(jr)
-        end
-      end
-
-      def remove_wme(wme)
-        return unless by_wme.key?(wme)
-
-        by_wme[wme].keys do |jr|
-          remove(jr)
-        end
-      end
-    end
-
-    attr_reader :rete, :parent, :wmes, :tokens, :indexes, :queue, :hidden_parent_wmes, :hidden_parent_tokens, :wme_generators, :hidden_parent_wme_generators, :wme_manual, :hidden_parent_wme_manual, :neg_join_results, :opt_join_results, :ncc_tokens, :ncc_tokens_owner, :hidden_ncc_tokens
+    attr_reader :rete, :parent, :wmes, :tokens, :indexes, :queue, :hidden_parent_wmes, :hidden_parent_tokens, :generator_tracker, :wme_manual, :hidden_parent_wme_manual, :neg_join_results, :opt_join_results, :ncc_tokens, :ncc_tokens_owner, :hidden_ncc_tokens
     private :wmes, :tokens
     private :indexes
     private :queue
     private :hidden_parent_wmes
     private :hidden_parent_tokens
-    private :wme_generators
-    private :hidden_parent_wme_generators
+    private :generator_tracker
     private :wme_manual
     private :hidden_parent_wme_manual
     private :neg_join_results
@@ -111,10 +32,9 @@ module Wongi::Engine
       @hidden_parent_wmes = {}
 
       @tokens = Hash.new { |h, k| h[k] = [] }
-      @hidden_parent_tokens = {}
+      @hidden_parent_tokens = Set.new
 
-      @wme_generators = Hash.new { |h, k| h[k] = [] }
-      @hidden_parent_wme_generators = {}
+      @generator_tracker = GeneratorTracker.new
 
       @wme_manual = {}
       @hidden_parent_wme_manual = {}
@@ -140,14 +60,6 @@ module Wongi::Engine
       parent.ancestor?(other)
     end
 
-    def dispose!
-      return if default?
-
-      tokens.each do |_node, tokens|
-        tokens.each(&:dispose!)
-      end
-    end
-
     def <<(thing)
       case thing
       when Array
@@ -180,19 +92,23 @@ module Wongi::Engine
     def run_queue
       until queue.empty?
         operation, wme, options = queue.shift
+
         case operation
         when :assert
-          wme = find_ignoring_hidden(wme) || wme
+          existing_wme = find_ignoring_hidden(wme)
+          wme = existing_wme || wme
           visible = !find(wme).nil?
           add_wme(wme, **options)
           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
+          if wme # 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) if visible
+          end
 
-          visible = !find(wme).nil?
-          remove_wme(wme, **options)
-          rete.real_retract(wme) if visible
         end
       end
     end
@@ -226,12 +142,12 @@ module Wongi::Engine
       when 1
         case args.first
         when Template
-          select_by_template(args.first)
+          each_by_template(args.first)
         else
           raise ArgumentError
         end
       when 3
-        select_by_template(Template.new(*args))
+        each_by_template(Template.new(*args))
       else
         raise ArgumentError
       end
@@ -248,28 +164,22 @@ module Wongi::Engine
       generators(wme).any?
     end
 
-    def generated_by?(wme, gen)
-      own_generated_by?(wme, gen) ||
+    def generators(wme)
+      Enumerator.new do |y|
+        generator_tracker.for_wme(wme).each {  y << _1 }
         if parent
-          parent.generated_by?(wme, gen) && !hidden_parent_wme_generators.key?(gen)
-        else
-          false
+          parent.generators(wme).reject { hidden_token?(_1) }.each { y << _1 }
         end
+      end
     end
 
-    private def own_generated_by?(wme, gen)
-      wme_generators.key?(wme) && wme_generators[wme].include?(gen)
-    end
-
-    def generators(wme)
-      own_generators = wme_generators.key?(wme) ? wme_generators[wme] : []
-      parent_generators =
-        if parent
-          parent.generators(wme).reject { |g| hidden_parent_wme_generators.key?(g) }
-        else
-          []
+    def generated_wmes(token)
+      Enumerator.new do |y|
+        generator_tracker.for_token(token).each { y << _1 }
+        if parent && !hidden_token?(token)
+          parent.generated_wmes(token).reject { hidden_wme?(_1) }.each { y << _1 }
         end
-      own_generators + parent_generators
+      end
     end
 
     private def own_manual?(wme)
@@ -277,7 +187,7 @@ module Wongi::Engine
     end
 
     private def own_generated?(wme)
-      wme_generators.key?(wme) && wme_generators[wme].any?
+      generator_tracker.for_wme(wme).any?
     end
 
     private def find_wme(wme)
@@ -285,7 +195,11 @@ module Wongi::Engine
     end
 
     private def find_own_wme(wme)
-      wmes.include?(wme) ? wme : nil
+      has_own_wme?(wme) ? wme : nil
+    end
+
+    private def has_own_wme?(wme)
+      wmes.include?(wme)
     end
 
     private def find_parents_wme(wme)
@@ -302,28 +216,29 @@ module Wongi::Engine
         end
     end
 
-    private def select_by_template(template)
-      select_parents_template(template) + select_own_template(template)
+    def each_by_template(template)
+      Enumerator.new do |y|
+        each_own_wme_by_template(template, y)
+        each_parent_wme_by_template(template, y)
+      end
     end
 
-    private def select_own_template(template)
+    private def each_own_wme_by_template(template, y)
       if template.concrete?
         wme = find_own_wme(WME.from_concrete_template(template))
-        wme ? [wme] : []
+        y << wme if wme
       elsif template.root?
-        wmes
+        wmes.each { y << _1 }
       else
         indexes.map { |index|
           index.collections_for_template(template)
-        }.compact.first
+        }.compact.first.each { y << _1 }
       end
     end
 
-    private def select_parents_template(template)
+    private def each_parent_wme_by_template(template, y)
       if parent
-        parent.select(template).reject { hidden_wme?(_1) }.to_set
-      else
-        Set.new
+        parent.each_by_template(template).reject { hidden_wme?(_1) }.each { y << _1 }
       end
     end
 
@@ -332,32 +247,17 @@ module Wongi::Engine
 
       # if we previously hid this locally, unhide it
       hidden_parent_wmes.delete(wme)
-      if generator
-        hidden_parent_wme_generators.delete(generator)
-      else
-        hidden_parent_wme_manual.delete(wme)
-      end
 
-      if find_own_wme(wme)
-        if generator
-          wme_generators[wme] << generator unless own_generated_by?(wme, generator)
-        else
-          wme_manual[wme] = true
-        end
-      elsif find_parents_wme(wme)
-        if generator
-          wme_generators[wme] << generator unless generated_by?(wme, generator)
-        else
-          wme_manual[wme] = true unless manual?(wme)
-        end
-      else
+      unless has_own_wme?(wme)
         wmes.add(wme)
         indexes.each { _1.add(wme) }
-        if generator
-          wme_generators[wme] << generator
-        else
-          wme_manual[wme] = true
-        end
+      end
+
+      if generator
+        generator_tracker.add(wme, generator)
+      else
+        hidden_parent_wme_manual.delete(wme)
+        wme_manual[wme] = true
       end
     end
 
@@ -365,15 +265,9 @@ module Wongi::Engine
       # p remove_wme: { wme:, generator: !!generator }
 
       if find_own_wme(wme)
-        if generator
-          if own_generated_by?(wme, generator)
-            wme_generators[wme].delete(generator)
-            wme_generators.delete(wme) if wme_generators[wme].empty?
-          end
-        elsif own_manual?(wme)
-          wme_manual.delete(wme)
-        end
+        wme_manual.delete(wme) if generator.nil?
 
+        # no remaining reasons to keep this WME around
         if !own_generated?(wme) && !own_manual?(wme)
           wmes.delete(wme)
           indexes.each { _1.remove(wme) }
@@ -388,23 +282,10 @@ module Wongi::Engine
 
       # must be parents' then
 
-      if generator
-        # first, delete local
-        if own_generated_by?(wme, generator)
-          wme_generators[wme].delete(generator)
-          wme_generators.delete(wme) if wme_generators[wme].empty?
-        end
-        # if we're still generated, hide parents'
-        if generated_by?(wme, generator)
-          hidden_parent_wme_generators[generator] = true
-        end
-      else
-        if own_manual?(wme)
-          wme_manual.delete(wme)
-        end
-        if manual?(wme)
-          hidden_parent_wme_manual[wme] = true
-        end
+      if generator.nil?
+        wme_manual.delete(wme)
+        # if still manual, it must be from the parent
+        hidden_parent_wme_manual[wme] = true if manual?(wme)
       end
 
       if !manual?(wme) && !generated?(wme)
@@ -416,7 +297,8 @@ module Wongi::Engine
       # p add_token: {token:}
       # TODO: is this really likely to happen? we don't normally restore deleted tokens but rather create new ones in the activation
       if hidden_token?(token)
-        hidden_parent_tokens.delete(token.object_id)
+        puts "odd case"
+        unhide_token(token)
         return
       end
 
@@ -425,9 +307,13 @@ module Wongi::Engine
 
     def remove_token(token)
       # p remove_token: {token:}
+
+      # capture the entire enumerated state
+      wmes = generated_wmes(token).to_a
+
       if own_node_tokens(token.node).find { _1.equal?(token) }.nil?
         if parents_node_tokens(token.node).find { _1.equal?(token) }
-          hidden_parent_tokens[token.object_id] = true
+          hide_token(token)
 
           # do not hide JRs from the WME side: it will be done in the alpha deactivation and the JRs have to stay visible until then
           parent_neg_join_results_for(token: token).each { neg_join_results.hide(_1) }
@@ -437,10 +323,12 @@ module Wongi::Engine
             hidden_ncc_tokens[token][ncc] = true
           end
         end
-        return
+      else
+        remove_own_token(token)
       end
 
-      remove_own_token(token)
+      wmes.each { retract(_1, generator: token) }
+
     end
 
     def remove_own_token(token)
@@ -448,6 +336,7 @@ module Wongi::Engine
       tokens[token.node.object_id].delete(token)
       neg_join_results.remove_token(token)
       opt_join_results.remove_token(token)
+      generator_tracker.remove_token(token)
 
       # if this is an NCC partner token
       if (owner = ncc_tokens_owner[token])
@@ -465,9 +354,6 @@ module Wongi::Engine
       end
       ncc_tokens.delete(token)
       hidden_ncc_tokens.delete(token)
-
-      # we know we are the owner, and nobody wants it anymore, so this is the safe place to do it
-      token.dispose!
     end
 
     def node_tokens(beta)
@@ -482,7 +368,7 @@ module Wongi::Engine
 
     private def parents_node_tokens(beta)
       if parent
-        parent.node_tokens(beta).reject { hidden_parent_tokens.key?(_1.object_id) }
+        parent.node_tokens(beta).reject { hidden_token?(_1) }
       else
         []
       end
@@ -581,7 +467,15 @@ module Wongi::Engine
     end
 
     private def hidden_token?(token)
-      hidden_parent_tokens.key?(token.object_id)
+      hidden_parent_tokens.include?(token.object_id)
+    end
+
+    private def hide_token(token)
+      hidden_parent_tokens.add(token.object_id)
+    end
+
+    private def unhide_token(token)
+      hidden_parent_tokens.delete(token.object_id)
     end
   end
 end

data/lib/wongi-engine/token.rb

@@ -2,16 +2,13 @@ require 'set'
 
 module Wongi::Engine
   class Token
-    attr_reader :wme, :node, :generated_wmes, :parents
+    attr_reader :wme, :node, :parents
 
     def initialize(node, parents, wme, assignments = {})
       @node = node
       @parents = Set.new(Array(parents))
       @wme = wme
       @assignments = assignments
-      @deleted = false
-      @ncc_results = []
-      @generated_wmes = []
     end
 
     def ancestors
@@ -30,12 +27,18 @@ module Wongi::Engine
       @assignments[variable] = value
     end
 
+    def own_assignments
+      @assignments
+    end
+
     def assignments
-      all_assignments
+      parents.each_with_object({}) do |parent, acc|
+        acc.merge!(parent.assignments)
+      end.merge(own_assignments)
     end
 
     def [](var)
-      a = assignments[var]
+      a = assignment(var)
       a.respond_to?(:call) ? a.call(self) : a
     end
 
@@ -43,8 +46,23 @@ module Wongi::Engine
       vars.map { self[_1] }
     end
 
+    def assignment(x)
+      return @assignments[x] if has_own_var?(x)
+
+      parents.each do |parent|
+        a = parent.assignment(x)
+        return a if a
+      end
+
+      nil
+    end
+
     def has_var?(x)
-      assignments.key? x
+      has_own_var?(x) || parents.any? { _1.has_var?(x) }
+    end
+
+    def has_own_var?(x)
+      @assignments.key?(x)
     end
 
     # TODO: ignore assignments?
@@ -52,12 +70,12 @@ module Wongi::Engine
       instance_of?(other.class) &&
         parents == other.parents &&
         wme == other.wme &&
-        assignments == other.assignments
+        own_assignments == other.own_assignments
     end
 
     def to_s
       str = "TOKEN [ #{object_id} ancestors=#{ancestors.map(&:object_id).map(&:to_s).join('.')} "
-      all_assignments.each_pair { |key, value| str << "#{key}=#{value.is_a?(TokenAssignment) ? "#{value.call} (#{value})" : value} " }
+      assignments.each_pair { |key, value| str << "#{key}=#{value.is_a?(TokenAssignment) ? "#{value.call} (#{value})" : value} " }
       str << "]"
       str
     end
@@ -65,43 +83,5 @@ module Wongi::Engine
     def inspect
       to_s
     end
-
-    # def destroy
-    #   deleted!
-    # end
-
-    def dispose!
-      # parent.children.delete(self) if parent
-      # @parent = nil
-      @wme = nil
-    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
-
-    protected
-
-    def all_assignments
-      parents.each_with_object({}) do |parent, acc|
-        acc.merge!(parent.assignments)
-      end.merge(@assignments)
-    end
-  end
-
-  class FakeToken < Token
-    def initialize(token, wme, assignments) # rubocop:disable Lint/MissingSuper
-      @parent = token
-      @wme = wme
-      @assignments = assignments
-      # @children = []
-      @neg_join_results = []
-      @opt_join_results = []
-      @ncc_results = []
-      @generated_wmes = []
-    end
   end
 end

data/lib/wongi-engine/version.rb

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

data/lib/wongi-engine.rb

@@ -28,6 +28,8 @@ require 'wongi-engine/beta'
 require 'wongi-engine/dsl'
 require 'wongi-engine/ruleset'
 require 'wongi-engine/compiler'
+require 'wongi-engine/join_results'
+require 'wongi-engine/generator_tracker'
 require 'wongi-engine/overlay'
 require 'wongi-engine/enumerators'
 require 'wongi-engine/network'

data/spec/bug_specs/issue_4_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe "issue 4" do
-  it "correctlies retract pre-added items from within a rule" do
+  it "correctly retracts pre-added items from within a rule" do
     engine = Wongi::Engine.create
 
     10.times { |i| engine << [i, :is_number, true] }
@@ -22,11 +22,11 @@ describe "issue 4" do
     numbers = engine.select :_, :is_number, true
     evens = engine.select :_, :is_even, true
 
-    expect(numbers.size).to eq(0)
-    expect(evens.size).to eq(10)
+    expect(numbers.count).to eq(0)
+    expect(evens.count).to eq(10)
   end
 
-  it "correctlies retract post-added items from within a rule" do
+  it "correctly retracts post-added items from within a rule" do
     engine = Wongi::Engine.create
 
     engine.rule 'segregate' do
@@ -47,8 +47,8 @@ describe "issue 4" do
     numbers = engine.select :_, :is_number, true
     evens = engine.select :_, :is_even, true
 
-    expect(numbers.size).to eq(0)
-    expect(evens.size).to eq(5)
+    expect(numbers.count).to eq(0)
+    expect(evens.count).to eq(5)
   end
 
   # cascaded processing affects this
@@ -80,9 +80,9 @@ describe "issue 4" do
     evens = engine.select :_, :is_even, true
     odds = engine.select :_, :is_odd, true
 
-    expect(numbers.size).to eq(0)
-    expect(evens.size).to eq(5)
-    expect(odds.size).to eq(5)
+    expect(numbers.count).to eq(0)
+    expect(evens.count).to eq(5)
+    expect(odds.count).to eq(5)
   end
 
   it "does not lose track when another rule affects a set" do
@@ -126,8 +126,8 @@ describe "issue 4" do
     evens = engine.select :_, :is_even, true
     odds = engine.select :_, :is_odd, true
 
-    expect(numbers.size).to eq(5)
-    expect(evens.size).to eq(5)
-    expect(odds.size).to eq(5)
+    expect(numbers.count).to eq(5)
+    expect(evens.count).to eq(5)
+    expect(odds.count).to eq(5)
   end
 end

data/spec/high_level_spec.rb

@@ -115,10 +115,10 @@ describe Wongi::Engine::Network do
     engine << ["Bob", :age, 43]
 
     items = engine.select "Alice", :younger, "Bob"
-    expect(items.size).to eq(1)
+    expect(items.count).to eq(1)
 
     items = engine.select "Bob", :older, "Alice"
-    expect(items.size).to eq(1)
+    expect(items.count).to eq(1)
   end
 
   it 'uses collectors' do

data/spec/overlay_spec.rb

@@ -136,11 +136,6 @@ describe Wongi::Engine::Overlay do
 
       overlay.retract(wme)
       expect(overlay.find(wme)).to be_nil
-      expect(child1.find(wme)).to be_nil
-      expect(child2.find(wme)).to be_nil
-
-      child1.assert(wme)
-      expect(overlay.find(wme)).to be_nil
       expect(child1.find(wme)).to eq(wme)
       expect(child2.find(wme)).to eq(wme)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wongi-engine
 version: !ruby/object:Gem::Version
-  version: 0.4.0.pre.alpha9
+  version: 0.4.0.pre.alpha11
 platform: ruby
 authors:
 - Valeri Sokolov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-03 00:00:00.000000000 Z
+date: 2022-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -139,7 +139,9 @@ files:
 - lib/wongi-engine/filter/inequality_test.rb
 - lib/wongi-engine/filter/less_than_or_equal_test.rb
 - lib/wongi-engine/filter/less_than_test.rb
+- lib/wongi-engine/generator_tracker.rb
 - lib/wongi-engine/graph.rb
+- lib/wongi-engine/join_results.rb
 - lib/wongi-engine/network.rb
 - lib/wongi-engine/network/collectable.rb
 - lib/wongi-engine/network/debug.rb