ruleby 0.3 → 0.4

data/lib/core/atoms.rb

@@ -14,33 +14,24 @@ module Ruleby
   module Core
   
   class Atom     
-    attr_reader:name
-    attr_reader:tag
-    attr_reader:proc
-    attr_reader:clazz
+    attr_reader :tag, :proc, :method, :deftemplate
     
-    def initialize(tag, name, clazz, &block)
+    def initialize(tag, method, deftemplate, &block)
       @tag = tag
-      @name = name
-      @clazz = clazz
+      @method = method
+      @deftemplate = deftemplate
       @proc = Proc.new(&block) if block_given?
-      
-      # QUESTION we should probably change the '@clazz' variable to be called
-      # something else.  Like '@deftemplate' maybe?
-      
-      # QUESTION we should probably change the '@name' variable to be called
-      # something else.  Like '@method' maybe?
     end    
     
     def to_s
-      return "#{self.class}, tag=#{@tag}, name=#{@name}, class=#{@clazz}"
+      return "#{self.class},#{@tag},#{@method},#{@deftemplate}"
     end
   end
   
-  # This kind of atom is used to match just a single, hard coded value.  
+  # This kind of atom is used to match a simple condition.  
   # For example:
   # 
-  #   a.name = 'John' 
+  #   a.person{ |p| p.is_a? Person }
   # 
   # So there are no references to other atoms.
   class PropertyAtom < Atom    
@@ -49,36 +40,72 @@ module Ruleby
     end   
     
     def shareable?(atom)
-      return atom && @name == atom.name && @clazz = atom.clazz && @proc == atom.proc 
+      return PropertyAtom === atom && 
+             @method == atom.method && 
+             @deftemplate == atom.deftemplate && 
+             @proc == atom.proc 
+    end
+  end  
+  
+  # TODO use this
+  class BlockAtom < PropertyAtom
+    def shareable?(atom)
+      return super &&
+             BlockAtom === atom &&              
+             @proc == atom.proc 
+    end
+  end
+  
+  # This kind of atom is used to match just a single, hard coded value.  
+  # For example:
+  # 
+  #   a.name == 'John' 
+  # 
+  # So there are no references to other atoms.
+  class EqualsAtom < PropertyAtom
+    attr_reader :value
+    def initialize(tag, method, deftemplate, value)
+      super(tag,method,deftemplate)
+      @value = value
+    end
+    
+    def shareable?(atom)
+      return EqualsAtom === atom && 
+             @method == atom.method && 
+             @deftemplate == atom.deftemplate 
     end
   end
   
   # This kind of atom is used to match a class type.  For example:
   # 
-  #   p.has Person 
+  #   'For each Person as :p'
   # 
   # It is only used at the start of a pattern.
-  class TypeAtom < Atom
-    def initialize(tag, clazz)      
-      super tag, :class, clazz do |t| t == clazz end
+  class HeadAtom < Atom
+    def initialize(tag, deftemplate)   
+      if deftemplate.mode == :equals
+        super tag, :class, deftemplate do |t| t == deftemplate.clazz end
+      elsif deftemplate.mode == :inherits
+        super tag, :class, deftemplate do |t| t === deftemplate.clazz end
+      end
     end
     
     def shareable?(atom)
-      return atom && @clazz = atom.clazz
+      return HeadAtom === atom && @deftemplate == atom.deftemplate
     end
   end
   
   # This kind of atom is used for matching a value that is a variable.
   # For example:
-  # 
-  #   a.name = :your_name, :%
+  #
+  #   #name == #:your_name
   #   
   # The expression for this atom depends on some other atom.  
   class ReferenceAtom < Atom  
     attr_reader :vars
     
-    def initialize(tag, name, vars, clazz, &block) 
-      super(tag, name, clazz, &block)
+    def initialize(tag, method, vars, deftemplate, &block) 
+      super(tag, method, deftemplate, &block)
       @vars = vars # list of referenced variable names
     end    
     
@@ -87,7 +114,11 @@ module Ruleby
     end
     
     def ==(atom)      
-      return atom.kind_of?(ReferenceAtom) && @proc == atom.proc && @tag == atom.tag && @vars == atom.vars
+      return ReferenceAtom === atom && 
+             @proc == atom.proc && 
+             @tag == atom.tag && 
+             @vars == atom.vars && 
+             @deftemplate == atom.deftemplate
     end
     
     def to_s
@@ -100,6 +131,24 @@ module Ruleby
   # *methods* that this atom references (not the variable names)!
   class SelfReferenceAtom < ReferenceAtom
   end
+  
+  # This class encapsulates the criteria the HeadAtom uses to match.  The clazz
+  # attribute represents a Class type, and the mode defines whether the head 
+  # will match only class that are exactly a particular type, or if it will 
+  # match classes that inherit that type also.
+  class DefTemplate
+    attr_reader :clazz
+    attr_reader :mode
+    
+    def initialize(clazz,mode=:equals)
+      @clazz = clazz
+      @mode = mode
+    end    
+    
+    def ==(df)
+      DefTemplate === df && df.clazz == @clazz && df.mode == @mode
+    end    
+  end
 
 end
 end

data/lib/core/engine.rb

@@ -30,8 +30,8 @@ module Ruleby
       @priority = 0
     end
             
-    def fire(r, match)
-      @proc.call(r, match)        
+    def fire(match)
+      @proc.call(match)        
     end 
        
     def ==(a2)
@@ -55,9 +55,9 @@ module Ruleby
       @used = false
     end   
     
-    def fire(r)
+    def fire()
       @used = true
-      @action.fire r, @match
+      @action.fire @match
     end
     
     def <=>(a2)          
@@ -135,6 +135,8 @@ module Ruleby
   # inference engine will compare these facts with the rules to produce some
   # outcomes.  
   class WorkingMemory
+    attr_reader :facts
+    
     def initialize
       @recency = 0
       @facts = Array.new
@@ -181,6 +183,10 @@ module Ruleby
       @conflict_resolver = cr
       @wm_altered = false
     end
+    
+    def facts
+      @working_memory.facts.collect{|f| f.object}
+    end
   
     # This method id called to add a new fact to working memory
     def assert(object,&block)
@@ -217,7 +223,7 @@ module Ruleby
           agenda = @conflict_resolver.resolve agenda            
           activation = agenda.pop   
           used_agenda.push activation     
-          activation.fire self       
+          activation.fire   
           if @wm_altered          
             agenda = @root.matches(false)    
             @root.increment_counter

data/lib/core/nodes.rb

@@ -18,7 +18,8 @@ module Ruleby
   class RootNode          
     def initialize(working_memory)
       @working_memory = working_memory
-      @type_nodes = {}
+      @type_node = nil
+      @inherit_nodes = []
       @atom_nodes = [] 
       @join_nodes = []
       @terminal_nodes = []
@@ -37,14 +38,10 @@ module Ruleby
     # this method is called.  It finds any nodes that depend on it, and updates
     # them accordingly.
     def assert_fact(fact) 
-      node = @type_nodes[fact.object.class]
-      if node
-        if fact.token == :plus
-          node.assert(fact)
-        else
-          node.retract fact 
-        end
-      end   
+      @type_node and fact.token == :plus ? @type_node.assert(fact) : @type_node.retract(fact) 
+      @inherit_nodes.each do |node|
+        fact.token == :plus ? node.assert(fact) : node.retract(fact) 
+      end
     end
         
     # Increments the activation counter.  This is just a pass-thru to the static 
@@ -78,11 +75,15 @@ module Ruleby
     end
     
     def print
-      puts 'NETWORK:'
-      @terminal_nodes.each do |node|
-        node.print(' ')
+      puts 'NETWORK:'    
+      @terminal_nodes.each do |n|
+        n.print(' ')
       end
     end
+
+    def child_nodes
+      return @inherit_nodes + [@type_node]
+    end
     
     private 
     
@@ -116,27 +117,31 @@ module Ruleby
       #   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)
-        
+        type_node = create_type_node(pattern)                
+        forked = false
+        parent_atom = pattern.atoms[0]
         parent_node = type_node
-        for i in (1..(pattern.atoms.size-1))
-          node = nil
-          atom = pattern.atoms[i]
+        
+        pattern.atoms[1..-1].each do |atom|
+          # If the network has been forked, we don't want to share nodes anymore
+          forked = true if parent_node.forks?(parent_atom)
+          
           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)
+            node = create_property_node(atom,forked)
           end
-          parent_node.out_nodes.push node
+          parent_node.add_out_node node, parent_atom
           node.parent_nodes.push parent_node
           parent_node = node
+          parent_atom = atom
         end    
   
         bridge_node = create_bridge_node(pattern)
-        parent_node.out_nodes.push bridge_node
+        parent_node.add_out_node bridge_node, parent_atom
         bridge_node.parent_nodes.push parent_node
         parent_node = bridge_node
         
@@ -144,11 +149,11 @@ module Ruleby
         
         if out_node.kind_of?(JoinNode)
           adapter_node = create_adapter_node(side)
-          parent_node.out_nodes.push adapter_node
+          parent_node.add_out_node adapter_node
           parent_node = adapter_node
         end   
         
-        parent_node.out_nodes.push out_node            
+        parent_node.add_out_node out_node            
         compare_to_wm(type_node)       
         return type_node     
       end
@@ -172,29 +177,33 @@ module Ruleby
         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.add_out_node adapter_node
           parent_node = adapter_node
         end         
-        parent_node.out_nodes.push out_node      
+        parent_node.add_out_node 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
+        if InheritsPattern === pattern
+          node = InheritsNode.new pattern.atoms[0]
+          @inherit_nodes.each do |inode|
+            return inode if inode.shareable? node
+          end
+          @inherit_nodes << node
+          return node
+        else
+          return (@type_node ||= TypeNode.new pattern.atoms[0])
         end
-        return node
       end
       
       def create_bridge_node(pattern)
         return BridgeNode.new(pattern)
       end
       
-      def create_property_node(atom)
-        node = PropertyNode.new atom
+      def create_property_node(atom,forked)
+        node = atom.kind_of?(EqualsAtom) ? EqualsNode.new(atom) : PropertyNode.new(atom)
+        @atom_nodes.each {|n| return n if n.shareable? node} unless forked
         @atom_nodes.push node
         return node
       end
@@ -233,8 +242,7 @@ module Ruleby
   # Any node in the network that needs to be printed extends this class.  It
   # provides handles to the nodes above it in the network.  These are not used 
   # for matching (i.e. no backward-chaining).
-  class Printable
-  
+  class Printable  
     attr_reader:parent_nodes   
     
     def initialize
@@ -252,8 +260,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.
     def resolve(mr1, mr2)    
@@ -271,21 +278,32 @@ module Ruleby
   # This is the base class for all nodes in the network that output to some 
   # other node (i.e. they are not at the bottom). It contains methods for 
   # propagating match results.
-  class ParentNode < Node
-        
-    attr_reader:out_nodes 
-    
+  class ParentNode < Node    
+    attr_reader :child_nodes
     def initialize()
       super
       @out_nodes = []   
     end   
     
+    def add_out_node(node,atom=nil)
+      unless @out_nodes.index node
+        @out_nodes.push node
+      end
+    end
+    
+    # returns true if this node is already being used for the same atom.  That 
+    # is, if it is used again it will fork the network (or the network may 
+    # already be forked).
+    def forks?(atom)
+      return !@out_nodes.empty?
+    end
+    
     def retract(fact)
       propagate_retract(fact)
     end    
     
-    def propagate_retract(fact)
-      @out_nodes.each do |out_node|
+    def propagate_retract(fact,out_nodes=@out_nodes)
+      out_nodes.each do |out_node|
         out_node.retract(fact)
       end
     end
@@ -294,8 +312,8 @@ module Ruleby
       propagate_assert(assertable)
     end
     
-    def propagate_assert(assertable)
-      @out_nodes.each do |out_node|
+    def propagate_assert(assertable,out_nodes=@out_nodes)
+      out_nodes.each do |out_node|
         out_node.assert(assertable)
       end
     end
@@ -304,49 +322,132 @@ module Ruleby
   # 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. These nodes make
   # up the Alpha network.
-  class AtomNode < ParentNode
-  
-    attr_reader:atom
-    
+  class AtomNode < ParentNode  
+    attr_reader:atom    
     def initialize(atom)
       super()
       @atom = atom 
     end
+    
+    def ==(node)
+      return AtomNode === node && @atom == node.atom
+    end
+    
+    def shareable?(node)
+      return @atom.shareable?(node.atom)
+    end
+    
+    def to_s
+      super + " - #{@atom.method}"
+    end
   end
   
-  # This node class is used to match the type of a fact.
-  class TypeNode < AtomNode  
-    def assert(fact)   
-      propagate_assert(fact) if (@atom.clazz == fact.object.class)
+  # This is a base class for any node that hashes out_nodes by value.  A node 
+  # that inherits this class does not evaluate each condition, instead it looks
+  # up the expected value in the hash, and gets a list of out_nodes.
+  class HashedNode < AtomNode
+    def initialize(atom)
+      super
+      @values = {}
+      @values.default = []
+    end
+    
+    # returns true if this node is already being used for the same atom.  That 
+    # is, if it is used again it will fork the network (or the network may 
+    # already be forked).
+    def forks?(atom)      
+      k = hash_by(atom)   
+      return !@values[k].empty?
+    end
+    
+    def add_out_node(node,atom) 
+      k = hash_by(atom)
+      v = @values[k]
+      if v.empty?
+        @values[k] = [node]
+      elsif !v.index node
+        @values[k] = v << node
+      end
+    end
+    
+    def retract(fact)
+      propagate_retract fact, @values.values.flatten
+    end
+    
+    def assert(fact)     
+      k = fact.object.send(@atom.method)
+      propagate_assert fact, @values[k] 
+    rescue NoMethodError => e
+      # If the method does not exist, it is the same as if it evaluted to 
+      # false, and the network traverse stops
+    end
+  end
+  
+  # This node class is used to match the type of a fact.  In this case the type
+  # is matched exactly (ignoring inheritance).
+  class TypeNode < HashedNode    
+    def hash_by(atom) 
+      atom.deftemplate.clazz
+    end
+  end
+  
+  # This class is used for the same purpose as the TypeNode, but it matches 
+  # if the fact's inheritance chain includes the specified class.  
+  class InheritsNode < TypeNode
+    def assert(fact)
+      @values.each do |clazz,nodes| 
+        propagate_assert fact, nodes if clazz === fact.object
+      end
     end
   end
   
   # This node class is used for matching properties of a fact.
   class PropertyNode < AtomNode
     def assert(fact)
-      val = fact.object.send("#{@atom.name}")
-      propagate_assert(fact) if @atom.proc.call(val)
+      begin
+        val = fact.object.send(@atom.method)   
+      rescue NoMethodError => e
+        # If the method does not exist, it is the same as if it evaluted to 
+        # false, and the network traverse stops
+        return
+      end
+      super if @atom.proc.call(val)
     end
   end
   
+  # This node class is used for matching properties of a fact where the 
+  # condition is a simple '=='.  Instead of evaluating the condition, this node
+  # will pull from a hash.  This makes it significatly fast when it is shared.
+  class EqualsNode < HashedNode    
+    def hash_by(atom)
+      atom.value
+    end   
+  end  
+  
   # This node class is used to match properties of one with the properties
   # of any other already matched fact.  It differs from the other AtomNodes 
   # because it does not perform any inline matching.  The match method is only
   # invoked by the two input node.
   class ReferenceNode < AtomNode    
     def match(left_context,right_fact)
-      val = right_fact.object.send("#{@atom.name}")  
+      val = right_fact.object.send(@atom.method)  
       args = [val]            
       match = left_context.match
       @atom.vars.each do |var|
         args.push match.variables[var]   
-      end       
-      if @atom.proc.call(*args) 
-        m = MatchResult.new(match.variables.clone, true, match.fact_hash.clone, match.recency)
-        m.recency.push right_fact.recency
-        m.fact_hash[@atom.tag] = right_fact.id
-        m.variables[@atom.tag] = val 
-        return m
+      end    
+      begin
+        if @atom.proc.call(*args) 
+          m = MatchResult.new(match.variables.clone, true, 
+                              match.fact_hash.clone, match.recency)
+          m.recency.push right_fact.recency
+          m.fact_hash[@atom.tag] = right_fact.id
+          m.variables[@atom.tag] = val 
+          return m
+        end
+      rescue NoMethodError => e    
+        # If the method does not exist, it is the same as if it evaluted to 
+        # false, and the network traverse stops
       end
       return MatchResult.new
     end  
@@ -360,7 +461,7 @@ module Ruleby
     end
     
     def match(fact)
-      args = [fact.object.send("#{@atom.name}")]
+      args = [fact.object.send(@atom.method)]
       @atom.vars.each do |var|
         args.push fact.object.send(var)   
       end   
@@ -389,13 +490,10 @@ module Ruleby
           # 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}") 
+          mr[atom.tag] = fact.object.send(atom.method) 
         end
       end
-      
-      context = MatchContext.new(fact,mr)
-    
-      super(context)
+      super(MatchContext.new(fact,mr))
     end
   end  
     
@@ -561,9 +659,11 @@ module Ruleby
       end
     end
   
-    def assert_left(context)    
+   def assert_left(context)    
       add_to_left_memory(context)      
-      unless @ref_nodes.empty? && @right_memory.empty?
+      if @ref_nodes.empty? && @right_memory.empty?
+        propagate_assert(context)
+      else
         propagate = true
         @right_memory.values.each do |right_context|
           if match_ref_nodes(context,right_context)     
@@ -577,7 +677,11 @@ module Ruleby
     
     def assert_right(context)                    
       @right_memory[context.fact.id] = context
-      unless @ref_nodes.empty?
+      if @ref_nodes.empty?
+        @left_memory.values.flatten.each do |left_context|
+          propagate_retract_resolve(left_context.match)
+        end
+      else
         @left_memory.values.flatten.each do |left_context|
           if match_ref_nodes(left_context,context)
             # QUESTION is there a more efficient way to retract here?