ruleby 0.2 → 0.3

data/lib/core/nodes.rb

@@ -1,3 +1,14 @@
+# This file is part of the Ruleby project (http://ruleby.org)
+#
+# This application is free software; you can redistribute it and/or
+# modify it under the terms of the Ruby license defined in the
+# LICENSE.txt file.
+# 
+# Copyright (c) 2007 Joe Kutner and Matt Smith. All rights reserved.
+#
+# * Authors: Joe Kutner
+#
+
 module Ruleby
   module Core 
 
@@ -7,10 +18,7 @@ module Ruleby
   class RootNode          
     def initialize(working_memory)
       @working_memory = working_memory
-
-      # TODO once node sharing is implemented, @type_nodes will be a 
-      # Class=>TypeNode Hash.
-      @type_nodes = [] 
+      @type_nodes = {}
       @atom_nodes = [] 
       @join_nodes = []
       @terminal_nodes = []
@@ -20,171 +28,51 @@ module Ruleby
     # rule is processed and the appropriate nodes are added to the network.
     def assert_rule(rule)
       pattern = rule.pattern       
-      terminal_node = TerminalNode.new rule          
+      terminal_node = TerminalNode.new rule  
       build_network(pattern, terminal_node)             
       @terminal_nodes.push terminal_node
-    end
-    
-    # This method builds the network by starting at the bottom and recursively 
-    # working its way to the top.  The recursion goes up the left side of the 
-    # tree first (depth first... but our tree is up-side-down).
-    #  pattern - the pattern to process (Single or Composite)
-    #  out_node - the node that will be below the new node in the network
-    #  side - if the out_node is a JoinNode, this marks the side of the new node
-    #  Returns a new node in the network that wraps the given pattern and 
-    #  is above (i.e. it outputs to) the given node.
-    def build_network(pattern, out_node, side=nil) 
-      if (pattern.kind_of?(ObjectPattern))            
-        atom_node = create_atom_nodes(pattern, out_node, side) 
-        #out_node.parent_nodes.push atom_node # only used to print network
-        return atom_node
-      else  
-        join_node = create_join_node(pattern, out_node, side)  
-        build_network(pattern.left_pattern, join_node, :left)
-        build_network(pattern.right_pattern, join_node, :right) 
-        out_node.parent_nodes.push join_node # only used to print network
-        return join_node 
-      end
-    end
-    private:build_network
-          
-    # This method is used to create the atom nodes that make up the given 
-    # pattern's network.  It returns the node that is at the top of the network
-    # for the pattern.
-    #   pattern - the Pattern that the created node wraps
-    #   out_node - the Node that this pattern is directly above in thw network
-    #   side - if the out_node is a JoinNode, this marks the side of the new node
-    def create_atom_nodes(pattern, out_node, side)       
-      type_node = create_type_node(pattern.atoms[0])
-      
-      parent_node = type_node
-      for i in (1..(pattern.atoms.size-1))
-        node = nil
-        if pattern.atoms[i].kind_of?(SelfReferenceAtom)
-          node = create_self_reference_node(pattern.atoms[i])
-        elsif pattern.atoms[i].kind_of?(ReferenceAtom)
-          node = create_reference_node(pattern.atoms[i])
-          out_node.ref_nodes.push node
-        else
-          node = create_property_node(pattern.atoms[i])
-        end
-        parent_node.out_nodes.push node
-        node.parent_nodes.push parent_node
-        parent_node = node
-      end    
-      out_node.parent_nodes.push parent_node
-      
-      if out_node.kind_of?(JoinNode)
-        adapter_node = create_adapter_node(side)
-        parent_node.out_nodes.push adapter_node
-        parent_node = adapter_node
-      end   
-      
-      parent_node.out_nodes.push out_node            
-      compare_to_wm(type_node)       
-      return type_node     
-    end
-    private:create_atom_nodes
-        
-    # Creates a JoinNode, puts it at the middle of the network, and stores
-    # the node below it into its memory. 
-    #   pattern - the Pattern that the created node wraps
-    #   out_node - the Node that this pattern is directly above in thw network
-    #   side - if the out_node is a JoinNode, this marks the side of the new node
-    def create_join_node(pattern, out_node, side)      
-      join_node = nil
-      if (pattern.left_pattern.kind_of?(NotPattern))  
-        raise 'NotPatterns at the being of a rule are not yet supported'
-      elsif (pattern.right_pattern.kind_of?(NotPattern))  
-        join_node = NotNode.new 
-      else
-        join_node = JoinNode.new    
-      end
-      
-      @join_nodes.push(join_node)      
-      parent_node = join_node
-      if out_node.kind_of?(JoinNode)
-        adapter_node = create_adapter_node(side)
-        parent_node.out_nodes.push adapter_node
-        parent_node = adapter_node
-      end         
-      parent_node.out_nodes.push out_node      
-      return join_node      
-    end
-    private:create_join_node
-    
-    def create_type_node(atom)
-      node = TypeNode.new atom
-      @type_nodes.push node
-      return node
-    end
-    private:create_type_node
-    
-    def create_property_node(atom)
-      node = PropertyNode.new atom
-      @atom_nodes.push node
-      return node
-    end
-    private:create_property_node
-    
-    def create_self_reference_node(atom)      
-      node = SelfReferenceNode.new atom
-      @atom_nodes.push node
-      return node
-    end
-    private:create_self_reference_node
-    
-    def create_reference_node(atom)      
-      node = ReferenceNode.new atom
-      @atom_nodes.push node
-      return node
-    end
-    private:create_reference_node
-    
-    def create_adapter_node(side)
-      if side == :left
-        return LeftAdapterNode.new
-      else
-        return RightAdapterNode.new
-      end
-    end
-    private:create_adapter_node
-        
+    end    
+            
     # When a new fact is added to working memory, or an existing one is removed
     # this method is called.  It finds any nodes that depend on it, and updates
     # them accordingly.
     def assert_fact(fact) 
-      # TODO implement node sharing.  Instead of iterating over the @type_nodes
-      # list, we will just get the one that matches the type of this fact
-      @type_nodes.each do |node| 
+      node = @type_nodes[fact.object.class]
+      if node
         if fact.token == :plus
-          node.assert(MatchContext.new(fact))
+          node.assert(fact)
         else
           node.retract fact 
         end
       end   
     end
+        
+    # Increments the activation counter.  This is just a pass-thru to the static 
+    # variable in the terminal node
+    def increment_counter
+      TerminalNode.increment_counter
+    end
     
-    # This method is used to update each TypeAtomNode based on 
-    # the facts in working memory.  It can be a costly operation because it 
-    # iterates over EVERY fact in working memory.  It should only be used when a
-    # new rule is added.
-    def compare_to_wm(type_node)              
-      @working_memory.each_fact do |fact| 
-        type_node.assert MatchContext.new(fact)
-      end
+    # Resets the activation counter.  This is just a pass-thru to the static 
+    # variable in the terminal node
+    def reset_counter
+      TerminalNode.reset_counter
     end
-    private:compare_to_wm
   
     # When invoked, this method returns a list of all Action|MatchContext pairs 
     # as Activations.  The list is generated when facts and rules are asserted, 
     # so no comparisions are done here (i.e. no Backward Chaining).  
-    def match
+    def matches(initial=true)
       agenda = Array.new
       @terminal_nodes.each do |node|
-        if (node.satisfied?)
-          agenda.concat node.activations.values
-        end
+        node.activations.values.each do |a|
+          if initial
+            a.used = false 
+            agenda.push a 
+          elsif !a.used
+            agenda.push a 
+          end          
+        end 
       end
       return agenda
     end
@@ -195,17 +83,165 @@ module Ruleby
         node.print(' ')
       end
     end
+    
+    private 
+    
+      # This method builds the network by starting at the bottom and recursively 
+      # working its way to the top.  The recursion goes up the left side of the 
+      # tree first (depth first... but our tree is up-side-down).
+      #  pattern - the pattern to process (Single or Composite)
+      #  out_node - the node that will be below the new node in the network
+      #  side - if the out_node is a JoinNode, this marks the side 
+      #  Returns a new node in the network that wraps the given pattern and 
+      #  is above (i.e. it outputs to) the given node.
+      def build_network(pattern, out_node, side=nil) 
+        if (pattern.kind_of?(ObjectPattern))            
+          atom_node = create_atom_nodes(pattern, out_node, side) 
+          #out_node.parent_nodes.push atom_node # only used to print network
+          return atom_node
+        else  
+          join_node = create_join_node(pattern, out_node, side)  
+          build_network(pattern.left_pattern, join_node, :left)
+          build_network(pattern.right_pattern, join_node, :right) 
+          out_node.parent_nodes.push join_node # only used to print network
+          return join_node 
+        end
+      end
+            
+      # This method is used to create the atom nodes that make up the given 
+      # pattern's network.  It returns the node that is at the top of the 
+      # network for the pattern.
+      #   pattern - the Pattern that the created node wraps
+      #   out_node - the Node that this pattern is directly above in thw network
+      #   side - if the out_node is a JoinNode, this marks the side 
+      def create_atom_nodes(pattern, out_node, side)       
+        # TODO refactor this method so it clear and concise
+        type_node = create_type_node(pattern)
+        
+        parent_node = type_node
+        for i in (1..(pattern.atoms.size-1))
+          node = nil
+          atom = pattern.atoms[i]
+          if atom.kind_of?(SelfReferenceAtom)
+            node = create_self_reference_node(atom)
+          elsif atom.kind_of?(ReferenceAtom)
+            node = create_reference_node(atom)
+            out_node.ref_nodes.push node
+          else
+            node = create_property_node(atom)
+          end
+          parent_node.out_nodes.push node
+          node.parent_nodes.push parent_node
+          parent_node = node
+        end    
+  
+        bridge_node = create_bridge_node(pattern)
+        parent_node.out_nodes.push bridge_node
+        bridge_node.parent_nodes.push parent_node
+        parent_node = bridge_node
+        
+        out_node.parent_nodes.push parent_node
+        
+        if out_node.kind_of?(JoinNode)
+          adapter_node = create_adapter_node(side)
+          parent_node.out_nodes.push adapter_node
+          parent_node = adapter_node
+        end   
+        
+        parent_node.out_nodes.push out_node            
+        compare_to_wm(type_node)       
+        return type_node     
+      end
+          
+      # Creates a JoinNode, puts it at the middle of the network, and stores
+      # the node below it into its memory. 
+      #   pattern - the Pattern that the created node wraps
+      #   out_node - the Node that this pattern is directly above in thw network
+      #   side - if the out_node is a JoinNode, this marks the side 
+      def create_join_node(pattern, out_node, side)      
+        join_node = nil
+        if (pattern.left_pattern.kind_of?(NotPattern))  
+          raise 'NotPatterns at the being of a rule are not yet supported'
+        elsif (pattern.right_pattern.kind_of?(NotPattern))  
+          join_node = NotNode.new 
+        else
+          join_node = JoinNode.new    
+        end
+        
+        @join_nodes.push(join_node)      
+        parent_node = join_node
+        if out_node.kind_of?(JoinNode)
+          adapter_node = create_adapter_node(side)
+          parent_node.out_nodes.push adapter_node
+          parent_node = adapter_node
+        end         
+        parent_node.out_nodes.push out_node      
+        return join_node      
+      end
+      
+      def create_type_node(pattern)
+        atom = pattern.atoms[0]
+        node = @type_nodes[atom.clazz]    
+        unless node
+          node = TypeNode.new atom 
+          @type_nodes[atom.clazz] = node
+        end
+        return node
+      end
+      
+      def create_bridge_node(pattern)
+        return BridgeNode.new(pattern)
+      end
+      
+      def create_property_node(atom)
+        node = PropertyNode.new atom
+        @atom_nodes.push node
+        return node
+      end
+      
+      def create_self_reference_node(atom)   
+        node = SelfReferenceNode.new atom
+        @atom_nodes.push node
+        return node
+      end
+      
+      def create_reference_node(atom)      
+        node = ReferenceNode.new atom
+        @atom_nodes.push node
+        return node
+      end
+      
+      def create_adapter_node(side)
+        if side == :left
+          return LeftAdapterNode.new
+        else
+          return RightAdapterNode.new
+        end
+      end
+      
+      # This method is used to update each TypeNode based on the facts in 
+      # working memory.  It can be a costly operation because it iterates over 
+      # EVERY fact in working memory.  It should only be used when a new rule is 
+      # added.
+      def compare_to_wm(type_node)              
+        @working_memory.each_fact do |fact| 
+          type_node.assert MatchContext.new(fact)
+        end
+      end  
   end
   
   # Any node in the network that needs to be printed extends this class.  It
-  # provides handles to the nodes above it in network.  These are not used for
-  # matching (i.e. no backward-chaining).
+  # provides handles to the nodes above it in the network.  These are not used 
+  # for matching (i.e. no backward-chaining).
   class Printable
+  
+    attr_reader:parent_nodes   
+    
     def initialize
-      # this only used for printing the network, not for matching
+      # this is only used for printing the network, not for matching
       @parent_nodes = [] 
     end
-    attr_reader:parent_nodes   
+    
     def print(tab)
       puts tab + to_s
       @parent_nodes.each do |out_node|
@@ -216,7 +252,7 @@ module Ruleby
   
   # Base Node class used by all nodes in the network that do some kind 
   # of matching.
-  class Node < Printable    
+  class Node < Printable   
   
     # This method determines if all common tags have equal values.  If any 
     # values are not equal then the method returns false.
@@ -236,96 +272,61 @@ module Ruleby
   # other node (i.e. they are not at the bottom). It contains methods for 
   # propagating match results.
   class ParentNode < Node
-    def initialize
-      super
-      @out_nodes = []    
-    end
-    attr_reader:out_nodes
+        
+    attr_reader:out_nodes 
     
-    def assert(context)
-      propagate_assert(context)
-    end
+    def initialize()
+      super
+      @out_nodes = []   
+    end   
     
     def retract(fact)
       propagate_retract(fact)
-    end
+    end    
     
-    def propagate_assert(context)
+    def propagate_retract(fact)
       @out_nodes.each do |out_node|
-        out_node.assert(context)
+        out_node.retract(fact)
       end
     end
     
-    def propagate_retract(fact)
+    def assert(assertable)
+      propagate_assert(assertable)
+    end
+    
+    def propagate_assert(assertable)
       @out_nodes.each do |out_node|
-        out_node.retract(fact)
+        out_node.assert(assertable)
       end
     end
   end
   
   # This is a base class for all single input nodes that match facts based on
-  # some properties.  It is essentially a wrapper for an Atom.
+  # some properties.  It is essentially a wrapper for an Atom. These nodes make
+  # up the Alpha network.
   class AtomNode < ParentNode
+  
+    attr_reader:atom
+    
     def initialize(atom)
       super()
       @atom = atom 
     end
-    attr_reader:atom
-    
-    def retract(fact)
-      # These nodes do not have a memory, so there is no need to do anything
-      # when a fact is retracted.  Just pass it on to the two-input nodes.
-      propagate_retract(fact)
-    end
   end
   
   # This node class is used to match the type of a fact.
-  class TypeNode < AtomNode
-    def assert(context)
-      mr = match(context.fact)
-      if mr.is_match    
-        context.match.update mr
-        propagate_assert(context)
-      end
+  class TypeNode < AtomNode  
+    def assert(fact)   
+      propagate_assert(fact) if (@atom.clazz == fact.object.class)
     end
-    
-    def match(fact)
-      mr = MatchResult.new
-      val = fact.object.send("#{@atom.name}")
-      if @atom.proc.call(val)
-        mr.is_match = true
-        mr.recency.push fact.recency
-        mr.fact_hash[@atom.tag] = fact.id
-        mr[@atom.tag] = fact.object 
-      end
-      return mr
-    end
-    private:match
   end
   
   # This node class is used for matching properties of a fact.
   class PropertyNode < AtomNode
-    def assert(context)
-      mr = match(context.fact)
-      if mr.is_match
-        # TODO for node sharing will we have to update multiple matches
-        context.match.update mr
-        propagate_assert(context)
-      end
-    end
-    
-    def match(fact)
-      mr = MatchResult.new
+    def assert(fact)
       val = fact.object.send("#{@atom.name}")
-      if @atom.proc.call(val)
-        mr.is_match = true
-        mr.fact_hash[@atom.tag] = fact.id
-        mr.recency.push fact.recency
-        mr[@atom.tag] = val 
-      end
-      return mr
+      propagate_assert(fact) if @atom.proc.call(val)
     end
-    private:match
   end
   
   # This node class is used to match properties of one with the properties
@@ -336,8 +337,7 @@ module Ruleby
     def match(left_context,right_fact)
       val = right_fact.object.send("#{@atom.name}")  
       args = [val]            
-      # TODO for node sharing we will have to compare against multiple matches
-      match = left_context.match.dup     
+      match = left_context.match
       @atom.vars.each do |var|
         args.push match.variables[var]   
       end       
@@ -354,16 +354,51 @@ module Ruleby
   
   # This node class is used to match properties of a fact with other properties
   # of itself.  Unlike ReferenceAtom it does perform inline matching. 
-  class SelfReferenceNode < ReferenceNode    
-    def assert(context)
-      mr = match(context, context.fact)
-      if mr.is_match
-        context.match.update mr
-        propagate_assert(context)
-      end
+  class SelfReferenceNode < AtomNode    
+    def assert(fact)      
+      propagate_assert fact if match fact
+    end
+    
+    def match(fact)
+      args = [fact.object.send("#{@atom.name}")]
+      @atom.vars.each do |var|
+        args.push fact.object.send(var)   
+      end   
+      return @atom.proc.call(*args) 
     end
   end
   
+  # The BridgeNode is used to bridge the alpha network to either the beta 
+  # network, or to the terminal nodes.  It creates a partial match from the
+  # pattern and atoms above it in the network.  Thus, there is one bridge node
+  # for each pattern (assuming they aren't shared).
+  class BridgeNode < ParentNode 
+    def initialize(pattern)
+      super()
+      @pattern =  pattern
+    end
+  
+    def propagate_assert(fact)          
+      # create the partial match
+      mr = MatchResult.new
+      mr.is_match = true      
+      mr.recency.push fact.recency
+      @pattern.atoms.each do |atom|
+        mr.fact_hash[atom.tag] = fact.id
+        if atom == @pattern.head
+          # HACK its a pain to have to check for this, can we make it special
+          mr[atom.tag] = fact.object
+        else
+          mr[atom.tag] = fact.object.send("#{atom.name}") 
+        end
+      end
+      
+      context = MatchContext.new(fact,mr)
+    
+      super(context)
+    end
+  end  
+    
   # This class is used to plug nodes into the left input of a two-input JoinNode
   class LeftAdapterNode < ParentNode
     def propagate_assert(context)
@@ -379,8 +414,9 @@ module Ruleby
     end
   end
   
-  # This class is used to plug nodes into the right input of a two-input JoinNode
-  class RightAdapterNode < ParentNode
+  # This class is used to plug nodes into the right input of a two-input 
+  # JoinNode
+  class RightAdapterNode < ParentNode    
     def propagate_assert(context)
       @out_nodes.each do |out_node|
         out_node.assert_right(context)
@@ -396,15 +432,18 @@ module Ruleby
   
   # This class is a two-input node that is used to create a cross-product of the
   # two network branches above it.  It keeps a memory of the left and right 
-  # inputs and compares new facts to each.
+  # inputs and compares new facts to each.  These nodes make up what is called
+  # the Beta network.
   class JoinNode < ParentNode
+    
+    attr:ref_nodes,true
+    
     def initialize
       super
       @left_memory = {}
       @right_memory = {} 
       @ref_nodes = []
     end
-    attr:ref_nodes,true
     
     def retract_left(fact)
       @left_memory.delete(fact.id)
@@ -421,7 +460,6 @@ module Ruleby
       @right_memory.values.each do |right_context|
         mr = match_ref_nodes(context,right_context)      
         if (mr.is_match)
-          # TODO for node sharing we will have to update multiple matches
           new_context = MatchContext.new context.fact, mr  
           propagate_assert(new_context)
         end
@@ -433,62 +471,61 @@ module Ruleby
       @left_memory.values.flatten.each do |left_context|
         mr = match_ref_nodes(left_context,context)      
         if (mr.is_match)
-          # TODO for node sharing we will have to update multiple matches
-          new_context = MatchContext.new context.fact, mr              
+          new_context = MatchContext.new context.fact, mr                
           propagate_assert(new_context)
         end
       end
+    end    
+        
+    def to_s
+      return "#{self.class}:#{object_id} | #{@left_memory.values} | #{@right_memory}"
     end
     
-    def match_ref_nodes(left_context,right_context)
-      mr = right_context.match.dup
-      if @ref_nodes.empty?
-        return left_context.match.dup.update(mr)
-      else
-        # TODO for node sharing we will have to have a list of matches
-        @ref_nodes.each do |ref_node|
-          ref_mr = ref_node.match(left_context, right_context.fact)
-          if ref_mr.is_match
-            mr.update ref_mr
-          else
-            return MatchResult.new
+    private    
+      def match_ref_nodes(left_context,right_context)
+        mr = right_context.match
+        if @ref_nodes.empty?
+          return left_context.match.merge(mr)
+        else
+          @ref_nodes.each do |ref_node|
+            ref_mr = ref_node.match(left_context, right_context.fact)
+            if ref_mr.is_match
+              mr = mr.merge ref_mr
+            else
+              return MatchResult.new
+            end
           end
+          return mr
         end
-        return mr
       end
-    end
-    private:match_ref_nodes
-    
-    def add_to_left_memory(context)
-      lm = @left_memory[context.fact.id]
-      lm = [] unless lm      
-      lm.push context
-      @left_memory[context.fact.id] = lm      
-      # QUESTION for a little while we were having trouble with duplicate contexts
-      # being added to the left_memory.  Double check that this is not happening
-    end
-    
-    def propagate_retract_resolve(match)
-      @out_nodes.each do |o|
-        o.retract_resolve(match)
+      
+      def add_to_left_memory(context)
+        lm = @left_memory[context.fact.id]
+        lm = [] unless lm      
+        lm.push context
+        @left_memory[context.fact.id] = lm      
+        # QUESTION for a little while we were having trouble with duplicate 
+        # contexts being added to the left_memory.  Double check that this is 
+        # not happening
       end
-    end
-    
-    def retract_resolve(match)
-      # in this method we retract an existing match from memory if it resolves
-      # with the match given.  It would probably be better to check if it 
-      # resolves with a list of facts.  But the system is not set up for
-      # that yet.
-      @left_memory.each do |fact_id,contexts|
-        value.delete_if do |left_context|          
-          resolve(left_context.match, match)
-        end        
+      
+      def propagate_retract_resolve(match)
+        @out_nodes.each do |o|
+          o.retract_resolve(match)
+        end
+      end
+      
+      def retract_resolve(match)
+        # in this method we retract an existing match from memory if it resolves
+        # with the match given.  It would probably be better to check if it 
+        # resolves with a list of facts.  But the system is not set up for
+        # that yet.
+        @left_memory.each do |fact_id,contexts|
+          value.delete_if do |left_context|          
+            resolve(left_context.match, match)
+          end        
+        end
       end
-    end
-    
-    def to_s
-      return "#{self.class}:#{object_id} | #{@left_memory.values} | #{@right_memory}"
-    end
   end
   
   # This node class is used when a rule is looking for a fact that does not 
@@ -509,13 +546,15 @@ module Ruleby
       right_context = @right_memory.delete(fact.id)  
       unless right_context == @right_memory.default
         unless @ref_nodes.empty? && !@right_memory.empty?
-          @left_memory.values.each do |left_context|
-            # TODO we should cache the matches on the left that were unmatched 
-            # by a result from a NotPattern.  We could hash them by the right 
-            # match that caused this.  In that we woould not have to re-compare 
-            # the the left and right matches.
-            if match_ref_nodes(left_context,right_context)      
-              propagate_assert(left_context)
+          @left_memory.values.each do |lm|
+            lm.each do |left_context|
+              # TODO we should cache the matches on the left that were unmatched 
+              # by a result from a NotPattern.  We could hash them by the right 
+              # match that caused this.  That we way we would not have to 
+              # re-compare the the left and right matches.
+              if match_ref_nodes(left_context,right_context)      
+                propagate_assert(left_context)
+              end
             end
           end   
         end
@@ -562,10 +601,12 @@ module Ruleby
   end
   
   # This class represents the bottom node in the network.  There is a one to one
-  # relation betweek TerminalNodes and Rules.  A terminal node acts as a wrapper
+  # relation between TerminalNodes and Rules.  A terminal node acts as a wrapper
   # for a rule.  The class is responsible for keeping a memory of the 
   # activations that have been generated by the network.
   class TerminalNode < Node
+    @@counter = 0
+  
     def initialize(rule)
       super()
       @rule = rule
@@ -574,7 +615,9 @@ module Ruleby
     attr_reader:activations
   
     def assert(context)
-      @activations.add context.match.fact_ids, Activation.new(@rule.action, context.match)
+      match = context.match
+      a = Activation.new(@rule.action, match, @@counter)
+      @activations.add match.fact_ids, a
     end
     
     def retract(fact)
@@ -598,24 +641,13 @@ module Ruleby
         resolve(activation.match, match)
       end
     end    
-  end
-  
-  class MatchContext
-    def initialize(fact,mr=MatchResult.new)
-      @fact = fact
-      
-      # TODO for node sharing this will be a pattern=>match Hash
-      @match = mr   
-    end
-    attr_reader:fact
-    attr_reader:match
     
-    def to_s
-      return @match.to_s
+    def self.increment_counter
+      @@counter = @@counter + 1
     end
     
-    def ==(t)
-      return @fact == t.fact && @match == t.match
+    def self.reset_counter
+      @@counter = 0
     end
   end