ruleby 0.4 → 0.5

data/lib/core/atoms.rb

@@ -149,6 +149,10 @@ module Ruleby
       DefTemplate === df && df.clazz == @clazz && df.mode == @mode
     end    
   end
+  
+  class AtomFactory
+    # TODO add some convenience methods for creating atoms
+  end
 
 end
 end

data/lib/core/engine.rb

@@ -182,6 +182,7 @@ module Ruleby
       @working_memory = wm
       @conflict_resolver = cr
       @wm_altered = false
+      assert InitialFact.new
     end
     
     def facts
@@ -207,9 +208,16 @@ module Ruleby
       assert(object,&block)
     end
     
+    def retrieve(c)
+      facts.select {|f| f.kind_of?(c)}
+    end
+    
     # This method adds a new rule to the system.
     def assert_rule(rule)         
-      @root = RootNode.new(@working_memory) if @root == nil
+      if @root == nil
+        @root = RootNode.new(@working_memory) 
+        @root.reset_counter
+      end
       @root.assert_rule rule
     end
     

data/lib/core/nodes.rb

@@ -28,9 +28,8 @@ module Ruleby
     # This method is invoked when a new rule is added to the system.  The
     # rule is processed and the appropriate nodes are added to the network.
     def assert_rule(rule)
-      pattern = rule.pattern       
       terminal_node = TerminalNode.new rule  
-      build_network(pattern, terminal_node)             
+      build_network(rule.pattern, terminal_node)             
       @terminal_nodes.push terminal_node
     end    
             
@@ -96,10 +95,16 @@ module Ruleby
       #  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
+        if pattern.kind_of?(ObjectPattern)
+          if pattern.kind_of?(NotPattern) and (side==:left or !side)
+            # a NotPattern needs to be run through a NotNode, which is a beta node.
+            # So if the NotPattern is on the left (i.e. it is the first pattern),
+            # then we need to add a dummy pattern in front of it.
+            new_pattern = CompositePattern.new(InitialFactPattern.new, pattern)            
+            return build_network(new_pattern, out_node, side)
+          else 
+            return create_atom_nodes(pattern, out_node, side) 
+          end
         else  
           join_node = create_join_node(pattern, out_node, side)  
           build_network(pattern.left_pattern, join_node, :left)
@@ -117,7 +122,7 @@ 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
@@ -164,10 +169,7 @@ module Ruleby
       #   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))  
+        if (pattern.right_pattern.kind_of?(NotPattern))  
           join_node = NotNode.new 
         else
           join_node = JoinNode.new    
@@ -232,9 +234,10 @@ module Ruleby
       # 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)              
+      def compare_to_wm(type_node)            
         @working_memory.each_fact do |fact| 
-          type_node.assert MatchContext.new(fact)
+          type_node.retract fact
+          type_node.assert fact
         end
       end  
   end

data/lib/core/patterns.rb

@@ -99,9 +99,18 @@ module Ruleby
     end
 
   end
+  
+  class InitialFactPattern < ObjectPattern
+    def initialize
+      deftemplate = DefTemplate.new InitialFact, :equals
+      htag = GeneratedTag.new
+      head = HeadAtom.new htag, deftemplate
+      super(head, [])
+    end
+  end
 
   class PatternFactory
-    
+    # TODO add some convenience methods for creating patterns
   end
 end
 end

data/lib/core/utils.rb

@@ -11,454 +11,461 @@
 
 module Ruleby
   module Core
+    
+    # This class is used as a unique fact that is assert to an engine's working memory
+    # immediately after creation.  This fact is used mainly when a NotPattern is put
+    # at the begining of a rule.  This allows it to join the 'not' to something tangible.
+    class InitialFact
+      
+    end
   
-  # This class is a wrapper for the context under which the network executes for
-  # for a given fact.  It is essentially a wrapper for a fact and a partial
-  # match.
-  class MatchContext
+    # This class is a wrapper for the context under which the network executes for
+    # for a given fact.  It is essentially a wrapper for a fact and a partial
+    # match.
+    class MatchContext
   
-    attr_reader:fact
-    attr_reader:match
+      attr_reader:fact
+      attr_reader:match
     
-    def initialize(fact,mr)
-      @fact = fact      
-      @match = mr  
-    end
+      def initialize(fact,mr)
+        @fact = fact      
+        @match = mr  
+      end
     
-    def to_s
-      return @match.to_s
-    end
+      def to_s
+        return @match.to_s
+      end
     
-    def ==(t)
-      return t && @fact == t.fact && @match == t.match
+      def ==(t)
+        return t && @fact == t.fact && @match == t.match
+      end
     end
-  end
     
-  # This class represents a partial match.  It contains the variables, values,
-  # and some metadata about the match.  For the most part, this metadata is used
-  # during conflict resolution.
-  class MatchResult    
-    # TODO this class needs to be cleaned up so that we don't have a bunch of
-    # properties.  Instead, maybe it sould have a list of facts.    
+    # This class represents a partial match.  It contains the variables, values,
+    # and some metadata about the match.  For the most part, this metadata is used
+    # during conflict resolution.
+    class MatchResult    
+      # TODO this class needs to be cleaned up so that we don't have a bunch of
+      # properties.  Instead, maybe it sould have a list of facts.    
     
-    attr :variables, true
-    attr :is_match, true
-    attr :fact_hash, true
-    attr :recency, true
+      attr :variables, true
+      attr :is_match, true
+      attr :fact_hash, true
+      attr :recency, true
     
-    def initialize(variables=Hash.new,is_match=false,fact_hash={},recency=[])
-      @variables = variables      
+      def initialize(variables=Hash.new,is_match=false,fact_hash={},recency=[])
+        @variables = variables      
       
-      # a list of recencies of the facts that this matchresult depends on.
-      @recency = recency
+        # a list of recencies of the facts that this matchresult depends on.
+        @recency = recency
       
-      # notes where this match result is from a NotPattern or ObjectPattern
-      # TODO this isn't really needed anymore.  how can we get rid of it?
-      @is_match = is_match 
+        # notes where this match result is from a NotPattern or ObjectPattern
+        # TODO this isn't really needed anymore.  how can we get rid of it?
+        @is_match = is_match 
       
-      # a hash of fact.ids that each tag corresponds to
-      @fact_hash = fact_hash 
-    end
+        # a hash of fact.ids that each tag corresponds to
+        @fact_hash = fact_hash 
+      end
     
-    def []=(sym, object)
-      @variables[sym] = object
-    end
+      def []=(sym, object)
+        @variables[sym] = object
+      end
     
-    def [](sym)
-       return @variables[sym]
-    end
+      def [](sym)
+         return @variables[sym]
+      end
     
-    def fact_ids
-      return fact_hash.values.uniq
-    end
+      def fact_ids
+        return fact_hash.values.uniq
+      end
     
-    def ==(match)           
-      return match != nil && @variables == match.variables && @is_match == match.is_match && @fact_hash == match.fact_hash
-    end
+      def ==(match)           
+        return match != nil && @variables == match.variables && @is_match == match.is_match && @fact_hash == match.fact_hash
+      end
     
-    def key?(m)
-      return @variables.key?(m)
-    end
+      def key?(m)
+        return @variables.key?(m)
+      end
     
-    def keys
-      return @variables.keys
-    end
+      def keys
+        return @variables.keys
+      end
     
-    def update(mr)
-      @recency = @recency | mr.recency
-      @is_match = mr.is_match
-      @variables = @variables.update mr.variables      
-      @fact_hash = @fact_hash.update mr.fact_hash      
-      return self
-    end
+      def update(mr)
+        @recency = @recency | mr.recency
+        @is_match = mr.is_match
+        @variables = @variables.update mr.variables      
+        @fact_hash = @fact_hash.update mr.fact_hash      
+        return self
+      end
     
-    def dup     
-      dup_mr = MatchResult.new
-      dup_mr.recency = @recency.clone
-      dup_mr.is_match = @is_match
-      dup_mr.variables = @variables.clone
-      dup_mr.fact_hash = @fact_hash.clone       
-      return dup_mr
-    end
+      def dup     
+        dup_mr = MatchResult.new
+        dup_mr.recency = @recency.clone
+        dup_mr.is_match = @is_match
+        dup_mr.variables = @variables.clone
+        dup_mr.fact_hash = @fact_hash.clone       
+        return dup_mr
+      end
     
-    def merge!(mr)
-      return update(mr)
-    end
+      def merge!(mr)
+        return update(mr)
+      end
     
-    def merge(mr)
-      new_mr = MatchResult.new
-      new_mr.recency = @recency | mr.recency
-      new_mr.is_match = mr.is_match
-      new_mr.variables = @variables.merge mr.variables 
-      new_mr.fact_hash = @fact_hash.merge mr.fact_hash    
-      return new_mr
-    end
+      def merge(mr)
+        new_mr = MatchResult.new
+        new_mr.recency = @recency | mr.recency
+        new_mr.is_match = mr.is_match
+        new_mr.variables = @variables.merge mr.variables 
+        new_mr.fact_hash = @fact_hash.merge mr.fact_hash    
+        return new_mr
+      end
     
-    def clear
-      @variables = {}
-      @fact_hash = {}
-      @recency = []
-    end
+      def clear
+        @variables = {}
+        @fact_hash = {}
+        @recency = []
+      end
     
-    def delete(tag)
-      @variables.delete(tag)
-      @fact_hash.delete(tag)
-    end
+      def delete(tag)
+        @variables.delete(tag)
+        @fact_hash.delete(tag)
+      end
     
-    def to_s
-      s = '#MatchResult('
-      s = s + 'f)(' unless @is_match
-      s = s + object_id.to_s+')('
-      @variables.each do |key,value|
-        s += "#{key}=#{value}/#{@fact_hash[key]}, "
+      def to_s
+        s = '#MatchResult('
+        s = s + 'f)(' unless @is_match
+        s = s + object_id.to_s+')('
+        @variables.each do |key,value|
+          s += "#{key}=#{value}/#{@fact_hash[key]}, "
+        end
+        return s + ")"
       end
-      return s + ")"
     end
-  end
   
-  # This class is used when we need to have a Hash where keys and values are 
-  # mapped many-to-many.  This class allows for quick access of both key and 
-  # value.  It is similar to Multimap in C++ standard lib.
-  # This thing is a mess (and barely works). It needs to be refactored.
-  class MultiHash
-    def initialize(key=nil, values=[])
-      @i = 0
-      clear
-      if key
-        @keys = {key => []} 
-        values.each do |v|
-          xref = generate_xref()
-          xref_list = @keys[key]
-          xref_list.push xref
-          @keys[key] = xref_list
-          @values = {xref => v}
-          @backward_hash = {xref => [key]}
+    # This class is used when we need to have a Hash where keys and values are 
+    # mapped many-to-many.  This class allows for quick access of both key and 
+    # value.  It is similar to Multimap in C++ standard lib.
+    # This thing is a mess (and barely works). It needs to be refactored.
+    class MultiHash
+      def initialize(key=nil, values=[])
+        @i = 0
+        clear
+        if key
+          @keys = {key => []} 
+          values.each do |v|
+            xref = generate_xref()
+            xref_list = @keys[key]
+            xref_list.push xref
+            @keys[key] = xref_list
+            @values = {xref => v}
+            @backward_hash = {xref => [key]}
+          end
         end
       end
-    end
     
-    def empty?
-      return @keys.empty?
-    end
+      def empty?
+        return @keys.empty?
+      end
     
-    def rehash
-      @keys.rehash
-      @values.rehash
-      @backward_hash.rehash
-    end
+      def rehash
+        @keys.rehash
+        @values.rehash
+        @backward_hash.rehash
+      end
     
-    def value?(mr)
-      @values.value?(mr)
-    end
+      def value?(mr)
+        @values.value?(mr)
+      end
     
-    def clear
-      @keys = {}
-      @values = {}
-      @backward_hash = {}
-    end
+      def clear
+        @keys = {}
+        @values = {}
+        @backward_hash = {}
+      end
     
-    def values_by_id(id)
-      xrefs = @keys[id]
-      values = []
-      if xrefs
-        xrefs.each do |k|
-          values.push @values[k]
+      def values_by_id(id)
+        xrefs = @keys[id]
+        values = []
+        if xrefs
+          xrefs.each do |k|
+            values.push @values[k]
+          end
+        else
+          #???
         end
-      else
-        #???
+        return values
       end
-      return values
-    end
     
-    def each_key
-      @keys.each_key do |key|
-        yield(key)
+      def each_key
+        @keys.each_key do |key|
+          yield(key)
+        end
       end
-    end
     
-    def has_key?(key)
-      return @keys.has_key?(key)
-    end
+      def has_key?(key)
+        return @keys.has_key?(key)
+      end
     
-    def key?(key)
-      return has_key?(key)
-    end
+      def key?(key)
+        return has_key?(key)
+      end
     
-    def +(dh)
-      # TODO this can be faster
-      new_dh = dh.dup
-      dh.concat self.dup
-      return new_dh
-    end
+      def +(dh)
+        # TODO this can be faster
+        new_dh = dh.dup
+        dh.concat self.dup
+        return new_dh
+      end
      
-    def add(ids,val)
-      xref = generate_xref()      
-      ids.each do |id|
-        xref_list = @keys[id]
-        xref_list = [] if xref_list == @keys.default
-        xref_list.push xref             
-        @keys[id] = xref_list  
-      end       
-      @values[xref] = val    
-      @backward_hash[xref] = ids
-    end
+      def add(ids,val)
+        xref = generate_xref()      
+        ids.each do |id|
+          xref_list = @keys[id]
+          xref_list = [] if xref_list == @keys.default
+          xref_list.push xref             
+          @keys[id] = xref_list  
+        end       
+        @values[xref] = val    
+        @backward_hash[xref] = ids
+      end
     
-    # DEPRECATED
-    # WARN this method adds a value to the MultiHash only if it is unique.  It
-    # can be a fairly costly operation, and should be avoided.  We only 
-    # implemented this as part of a hack to get things working early on.
-    def add_uniq(ids,val)
-      xref = generate_xref()
-      exist_list = []
-      ids.each do |id|
-        xref_list = @keys[id]
-        if xref_list != @keys.default           
-          xref_list.each do |existing_xref|  
-            existing_val = @values[existing_xref] 
-            if existing_val 
-              if val == existing_val                        
-                xref = existing_xref 
-                exist_list.push id
-                break
+      # DEPRECATED
+      # WARN this method adds a value to the MultiHash only if it is unique.  It
+      # can be a fairly costly operation, and should be avoided.  We only 
+      # implemented this as part of a hack to get things working early on.
+      def add_uniq(ids,val)
+        xref = generate_xref()
+        exist_list = []
+        ids.each do |id|
+          xref_list = @keys[id]
+          if xref_list != @keys.default           
+            xref_list.each do |existing_xref|  
+              existing_val = @values[existing_xref] 
+              if existing_val 
+                if val == existing_val                        
+                  xref = existing_xref 
+                  exist_list.push id
+                  break
+                end
+              else
+                # HACK there shouldn't be any xrefs like this in the
+                # hash to being with.  Why are they there?
+                xref_list.delete(existing_xref)
+                @keys[id] = xref_list
               end
-            else
-              # HACK there shouldn't be any xrefs like this in the
-              # hash to being with.  Why are they there?
-              xref_list.delete(existing_xref)
-              @keys[id] = xref_list
-            end
-          end         
-        end             
-      end   
-      add_list = ids - exist_list   
-      add_list.each do |id|
-        xref_list = @keys[id]
-        xref_list = [] if xref_list == @keys.default
-        xref_list.push xref             
-        @keys[id] = xref_list  
-      end            
-      @values[xref] = val if exist_list.empty?
-      b_list = @backward_hash[xref]
-      if b_list
-        @backward_hash[xref] = b_list | ids
-      else
-        @backward_hash[xref] = ids
+            end         
+          end             
+        end   
+        add_list = ids - exist_list   
+        add_list.each do |id|
+          xref_list = @keys[id]
+          xref_list = [] if xref_list == @keys.default
+          xref_list.push xref             
+          @keys[id] = xref_list  
+        end            
+        @values[xref] = val if exist_list.empty?
+        b_list = @backward_hash[xref]
+        if b_list
+          @backward_hash[xref] = b_list | ids
+        else
+          @backward_hash[xref] = ids
+        end
       end
-    end
         
-    def each
-      @values.each do |xref,val|
-        ids = @backward_hash[xref]        
-        yield(ids,val)
+      def each
+        @values.each do |xref,val|
+          ids = @backward_hash[xref]        
+          yield(ids,val)
+        end
       end
-    end
     
-    def each_internal
-      @values.each do |xref,val|
-        ids = @backward_hash[xref]
-        yield(ids,xref,val)
-      end      
-    end
-    private:each_internal
+      def each_internal
+        @values.each do |xref,val|
+          ids = @backward_hash[xref]
+          yield(ids,xref,val)
+        end      
+      end
+      private:each_internal
     
-    def concat(multi_hash)
-      multi_hash.each do |ids,val|
-        add(ids,val)
+      def concat(multi_hash)
+        multi_hash.each do |ids,val|
+          add(ids,val)
+        end
       end
-    end
     
-    # DEPRECATED
-    # WARN see comments in add_uniq
-    def concat_uniq(double_hash)
-      double_hash.each do |ids,val|
-        add_uniq(ids,val)
+      # DEPRECATED
+      # WARN see comments in add_uniq
+      def concat_uniq(double_hash)
+        double_hash.each do |ids,val|
+          add_uniq(ids,val)
+        end
       end
-    end
     
-    def default
-      return @values.default
-    end
+      def default
+        return @values.default
+      end
         
-    def remove(id)      
-      xref_list = @keys.delete(id)
-      if xref_list != @keys.default
-        removed_values = []
-        xref_list.each do |xref|
-          value = @values.delete(xref)
-          removed_values.push value
-          id_list = @backward_hash.delete(xref)
-          id_list.each do |next_id|
-            remove_internal(next_id,xref) if next_id != id
+      def remove(id)      
+        xref_list = @keys.delete(id)
+        if xref_list != @keys.default
+          removed_values = []
+          xref_list.each do |xref|
+            value = @values.delete(xref)
+            removed_values.push value
+            id_list = @backward_hash.delete(xref)
+            id_list.each do |next_id|
+              remove_internal(next_id,xref) if next_id != id
+            end
           end
+          return removed_values
+        else
+  #        puts 'WARN: tried to remove from MultiHash where id does not exist'        
+          return default
         end
-        return removed_values
-      else
-#        puts 'WARN: tried to remove from MultiHash where id does not exist'        
-        return default
       end
-    end
     
-    def remove_internal(id,xref)
-      xref_list = @keys[id]
-      if xref_list # BUG this shouldn't be nil!
-        xref_list.delete(xref) 
-        if xref_list.empty?
-          @keys.delete(id)
-        else             
-          @keys[id] = xref_list
+      def remove_internal(id,xref)
+        xref_list = @keys[id]
+        if xref_list # BUG this shouldn't be nil!
+          xref_list.delete(xref) 
+          if xref_list.empty?
+            @keys.delete(id)
+          else             
+            @keys[id] = xref_list
+          end
         end
       end
-    end
-    private:remove_internal
-    
-    def remove_by_xref(ids,xref)
-      ids.each do |id|
-        xref_list = @keys[id]
-        xref_list.delete(xref) 
-        if xref_list.empty?
-          @keys.delete(id)
-        else             
-          @keys[id] = xref_list
+      private:remove_internal
+    
+      def remove_by_xref(ids,xref)
+        ids.each do |id|
+          xref_list = @keys[id]
+          xref_list.delete(xref) 
+          if xref_list.empty?
+            @keys.delete(id)
+          else             
+            @keys[id] = xref_list
+          end
         end
+        @values.delete(xref)
+        @backward_hash.delete(xref)
       end
-      @values.delete(xref)
-      @backward_hash.delete(xref)
-    end
-    private:remove_by_xref
-    
-    def delete_if
-      @values.delete_if do |xref,v|  
-        if yield(v)
-          id_list = @backward_hash.delete(xref)
-          id_list.each do |next_id|
-            remove_internal(next_id,xref)
+      private:remove_by_xref
+    
+      def delete_if
+        @values.delete_if do |xref,v|  
+          if yield(v)
+            id_list = @backward_hash.delete(xref)
+            id_list.each do |next_id|
+              remove_internal(next_id,xref)
+            end
+            true
+          else
+            false
           end
-          true
-        else
-          false
         end
       end
-    end
     
-    def values
-      return @values.values
-    end
+      def values
+        return @values.values
+      end
     
-    def keys
-      return @keys.keys
-    end
+      def keys
+        return @keys.keys
+      end
     
-    def dup
-      dup_mc = MultiHash.new
-      each do |ids,v|
-        dup_mc.add ids, v.dup
+      def dup
+        dup_mc = MultiHash.new
+        each do |ids,v|
+          dup_mc.add ids, v.dup
+        end
+        return dup_mc      
       end
-      return dup_mc      
-    end
     
-    def generate_xref()
-      @i = @i + 1
-      return @i
-    end
-    private:generate_xref
-    
-    # This method is for testing.  It ensures that all the Hash's
-    # and Array's are in order, and not corrupted (ex. some key points
-    # to a xref that does not exist in the match_results Hash).
-    def valid?
-      @keys.each do |id,xrefs|
-#        xref_list = @keys[id]
-#        if xref_list != @keys.default
-#          xref_list.each do |xref|
-#            id_list = @backward_hash[xref]
-#            unless id_list
-#              puts 'yup' 
-#              return false
-#            end
-#          end
-#        end
-        xrefs.each do |xref|
-          count = 0
-          xrefs.each do |xref2|
-            if xref == xref2 
-              count = count + 1
-              if count > 1
-                puts '(0) Duplicate xrefs in entry for keys' 
-                return false
+      def generate_xref()
+        @i = @i + 1
+        return @i
+      end
+      private:generate_xref
+    
+      # This method is for testing.  It ensures that all the Hash's
+      # and Array's are in order, and not corrupted (ex. some key points
+      # to a xref that does not exist in the match_results Hash).
+      def valid?
+        @keys.each do |id,xrefs|
+  #        xref_list = @keys[id]
+  #        if xref_list != @keys.default
+  #          xref_list.each do |xref|
+  #            id_list = @backward_hash[xref]
+  #            unless id_list
+  #              puts 'yup' 
+  #              return false
+  #            end
+  #          end
+  #        end
+          xrefs.each do |xref|
+            count = 0
+            xrefs.each do |xref2|
+              if xref == xref2 
+                count = count + 1
+                if count > 1
+                  puts '(0) Duplicate xrefs in entry for keys' 
+                  return false
+                end
               end
             end
-          end
         
-          mr = @match_results[xref] 
-          if mr == @match_results.default
-            puts '(1) Missing entry in @match_results for xref' 
-            return false
-          end
+            mr = @match_results[xref] 
+            if mr == @match_results.default
+              puts '(1) Missing entry in @match_results for xref' 
+              return false
+            end
           
-#          @match_results.each do |mr_xref,other_mr|
-#            if other_mr == mr && mr_xref != xref
-#              puts '(1a) Duplicate entry in @match_results'
-#              return false
-#            end
-#          end
+  #          @match_results.each do |mr_xref,other_mr|
+  #            if other_mr == mr && mr_xref != xref
+  #              puts '(1a) Duplicate entry in @match_results'
+  #              return false
+  #            end
+  #          end
           
-          id_list = @backward_hash[xref]
-          if id_list == @backward_hash.default
-            puts '(2) Missing entry in backward_hash for xref'
-            return false
-          end
+            id_list = @backward_hash[xref]
+            if id_list == @backward_hash.default
+              puts '(2) Missing entry in backward_hash for xref'
+              return false
+            end
           
-          if id_list.index(id) == nil
-            puts '(3) Entry in backward_hash is missing id'
-            return false
-          end
+            if id_list.index(id) == nil
+              puts '(3) Entry in backward_hash is missing id'
+              return false
+            end
                     
-          id_list.each do |ref_id|
-            unless ref_id == id
-              ref_xref_list = @keys[ref_id]
-              if ref_xref_list == @keys.default
-                puts '(4) Missing entry in keys for backward_hash id'
-                puts "#{id},#{mr},#{xref},#{ref_id}"
-                return false
-              end
+            id_list.each do |ref_id|
+              unless ref_id == id
+                ref_xref_list = @keys[ref_id]
+                if ref_xref_list == @keys.default
+                  puts '(4) Missing entry in keys for backward_hash id'
+                  puts "#{id},#{mr},#{xref},#{ref_id}"
+                  return false
+                end
               
-              if ref_xref_list.index(xref) == nil                
-                puts '(5) Entry in keys is missing xref'
-                puts "#{id},#{mr},#{xref},#{ref_id}"
-                return false
+                if ref_xref_list.index(xref) == nil                
+                  puts '(5) Entry in keys is missing xref'
+                  puts "#{id},#{mr},#{xref},#{ref_id}"
+                  return false
+                end
               end
             end
           end
-        end
-      end           
-      return true
-    end
-    private:valid?
+        end           
+        return true
+      end
+      private:valid?
      
-    def ==(dh)
-      # TODO need to implement this
-      return super
+      def ==(dh)
+        # TODO need to implement this
+        return super
+      end
     end
   end
-end
 end

data/lib/dsl/treetop/treetop_helper.rb

@@ -0,0 +1,23 @@
+
+module Ruleby
+    class TreetopHelper
+      
+      def self.rule(name, *args, &block) 
+        options = args[0].kind_of?(Hash) ? args.shift : {}        
+  
+        r = Ferrari::RuleBuilder.new name
+        args.each do |arg|
+          if arg.kind_of? Array
+            r.when(*arg)
+          else
+            raise 'Invalid condition.  All or none must be Arrays.'
+          end
+        end
+  
+        r.then(&block)
+        r.priority = options[:priority] if options[:priority]
+  
+        return r.build_rule
+      end
+    end
+end

data/lib/dsl/treetop/tt_dsl.treetop

@@ -0,0 +1,105 @@
+grammar Ruleby
+  rule root
+	  defrule* {
+			def get_rules			
+				rs = []
+				elements.each do |e|
+				  rs << e.get_rule()
+				end
+				return rs
+			end
+		}
+	end
+	
+  rule defrule
+		'rule' space name space foreach space action {
+			def get_rule()				
+			  action_text = action.text_value.strip
+			  action_text.gsub!('do', '')
+			  action_text.gsub!('end', '')
+				return foreach.get_rule(name.text_value.strip, action_text.strip)
+			end
+		}
+	end
+	
+	rule name
+		[a-zA-Z] [a-zA-Z0-9]* 
+	end
+	
+  rule foreach
+		'foreach' space head space symbol {
+		def get_rule(name, action_text)
+			class_name = head.text_value.strip
+			clazz = eval(class_name)
+	  	tag = symbol.text_value.strip	
+			tag = tag[1, tag.size - 1]
+			return Ruleby::TreetopHelper.rule(name, [clazz, tag.to_sym], &action_text)
+		end
+	}
+  end	
+
+	
+  rule action
+		'do' space (!'end' .)* 'end' space?
+	end
+	
+	
+	
+	rule head
+	  [A-Z] [a-zA-Z]*  
+	end
+	rule symbol
+	 ':' [a-zA-Z]+
+	end
+	rule where
+	  'where'
+	end
+	rule method
+	  symbol '.' [a-z] [a-zA-Z0-9]* 
+	end
+	rule string
+		'\'' [a-zA-Z0-9]* '\''
+	end
+	rule value
+	  method / '-'* [0-9]+ / symbol / string
+	end
+	rule expression
+	  value space (equal space value) / (not_equal space value) / (symbol)
+	end
+	
+	rule clause
+		expression more:(and_sign clause)* {
+		def populate
+			more.elements.each do |e|
+				e.clause.populate
+			end
+		end
+	}
+	end	
+	rule and_sign
+	  'AND' 
+	end
+	rule not_equal
+	  '!=' 
+	end
+	rule equal
+	  '=='  
+	end
+	
+  rule space
+	  white+
+	end
+
+
+	rule white
+	  blank / eol
+	end
+
+	rule blank
+	  [ \t]
+	end
+
+	rule eol
+	  ("\r" "\n"?) / "\n"
+	end
+end

data/tests/test.rb

@@ -12,4 +12,7 @@ require 'common'
 require 'test_duck_type'
 require 'test_self_reference'
 require 'test_re'
+require 'gets.rb'
+require 'test_assert_facts'
+require 'not_patterns'
 

metadata

@@ -1,20 +1,20 @@
 --- !ruby/object:Gem::Specification 
 name: ruleby
 version: !ruby/object:Gem::Version 
-  version: "0.4"
+  version: "0.5"
 platform: ruby
 authors: 
 - Joe Kutner
 - Matt Smith
-autorequire: ruleby
+autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2008-05-18 00:00:00 -05:00
+date: 2009-06-16 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
-description: 
+description: Ruleby is a rule engine written in the Ruby language. It is a system for executing a set  of IF-THEN statements known as production rules. These rules are matched to objects using  the forward chaining Rete algorithm. Ruleby provides an internal Domain Specific Language  (DSL) for building the productions that make up a Ruleby program.  Release Notes for Version 0.5 * reset the TerminalNode.counter when initializing the RootNode.  Thanks to Shashank for the patch. * added InitialFact so that NotPatterns can be put at the front of a rule [#1 status:resolved] * Improved rule assertion so that rules can be added after facts have been asserted [#9 state:resolved] * Added retrieve method to engine, and a unit-test for it
 email: matt@ruleby.org
 executables: []
 
@@ -33,6 +33,9 @@ files:
 - lib/dsl/ferrari.rb
 - lib/dsl/letigre.rb
 - lib/dsl/steel.rb
+- lib/dsl/treetop
+- lib/dsl/treetop/treetop_helper.rb
+- lib/dsl/treetop/tt_dsl.treetop
 - lib/dsl/yaml_dsl.rb
 - lib/rulebook.rb
 - lib/ruleby.rb
@@ -57,7 +60,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: 
+rubyforge_project: ruleby
 rubygems_version: 1.0.1
 signing_key: 
 specification_version: 2