ruleby 0.7 → 0.8.b1

data/lib/core/atoms.rb

@@ -136,7 +136,7 @@ module Ruleby
   # 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
+  class Template
     attr_reader :clazz
     attr_reader :mode
     
@@ -146,7 +146,7 @@ module Ruleby
     end    
     
     def ==(df)
-      DefTemplate === df && df.clazz == @clazz && df.mode == @mode
+      Template === df && df.clazz == @clazz && df.mode == @mode
     end    
   end
   

data/lib/core/engine.rb

@@ -1,269 +1,273 @@
-# 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, Matt Smith
-#
-
-require 'core/atoms'
-require 'core/patterns'
-require 'core/utils'
-require 'core/nodes'
-
-module Ruleby
-  module Core
-  
-  # An action is a wrapper for a code block that will be executed if a rule is
-  # satisfied.  
-  class Action    
-    attr_accessor :priority
-    attr_accessor :name
-    attr_reader   :matches
-    attr_reader   :proc
-    
-    def initialize(&block)
-      @name = nil
-      @proc = Proc.new(&block) if block_given?
-      @priority = 0
-    end
-            
-    def fire(match, engine=nil)
-      if @proc.arity == 2
-        @proc.call(match, engine)
-      else
-        @proc.call(match)
-      end
-    end 
-       
-    def ==(a2)
-      return @name == a2.name
-    end    
-  end   
- 
-  # An activation is an action/match pair that is executed if a rule is matched.
-  # It also contains metadata that can be used for conflict resolution if two 
-  # rules are satisfied by the same fact.
-  class Activation      
-    attr_reader   :action, :match
-    attr_accessor :counter, :used
-    
-    def initialize(action, match, counter=0)
-      @action = action
-      @match = match
-      @match.recency.sort!
-      @match.recency.reverse!
-      @counter = counter
-      @used = false
-    end   
-    
-    def fire(engine=nil)
-      @used = true
-      @action.fire @match, engine
-    end
-    
-    def <=>(a2)          
-      return @counter <=> a2.counter if @counter != a2.counter
-      return @action.priority <=> a2.action.priority if @action.priority != a2.action.priority           
-
-      # NOTE in order for this to work, the array must be reverse sorted
-      i = 0; while @match.recency[i] == a2.match.recency[i] && i < @match.recency.size-1 && i < a2.match.recency.size-1 
-        i += 1
-      end
-      return @match.recency[i] <=> a2.match.recency[i]
-    end
-    
-    def ==(a2)
-      return a2 != nil && @action == a2.action && @match == a2.match
-    end
-    
-    def to_s
-      return "[#{@action.name}-#{object_id}|#{@counter}|#{@action.priority}|#{@match.recency.join(',')}|#{@match.to_s}] "
-    end
-  end
- 
-  class Rule  
-    attr_accessor :pattern
-    attr_reader   :action, :name, :priority   
-    
-    def initialize(name, pattern=nil, action=nil, priority=0) 
-      @name = name
-      @pattern = pattern
-      @action = action  
-      @priority = priority    
-    end
-    
-    def priority=(p)
-      @priority = p
-      @action.priority = @priority
-    end    
-  end
-  
-  # A fact is an object that is stored in working memory.  The rules in the 
-  # system will either look for the existence or absence of particular facts.
-  class Fact      
-    attr :token, true
-    attr :recency, true    
-    attr_reader :object
-    
-    def initialize(object, token)
-      @token = token      
-      @object = object
-    end
-       
-    def id
-      return object.object_id
-    end
-    
-    def ==(fact)
-      return fact != nil && fact.id == id
-    end
-    
-    def to_s
-      return "[Fact |#{@recency}|#{@object.to_s}]"
-    end
-  end
-  
-  # A conflict resolver is used to order activations that become active at the 
-  # same time.  The default implementation sorts the agenda based on the 
-  # properties of the activation.
-  class RulebyConflictResolver   
-    def resolve(agenda) 
-      return agenda.sort
-    end    
-  end
-  
-  # The working memory is a container for all the facts in the system.  The
-  # 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
-    end
-    
-    def each_fact
-      @facts.each do |f|
-        yield(f)
-      end
-    end
-    
-    def assert_fact(fact)
-      raise 'The fact asserted cannot be nil!' unless fact.object
-      if (fact.token == :plus)
-        fact.recency = @recency
-        @recency += 1
-        @facts.push fact
-        return fact
-      else #if (fact.token == :minus)  
-        i = @facts.index(fact)
-        raise 'The fact to remove does not exist!' unless i
-        existing_fact = @facts[i]
-        @facts.delete_at(i)
-        existing_fact.token = fact.token
-        return existing_fact
-      end
-    end
-    
-    def print
-      puts 'WORKING MEMORY:'
-      @facts.each do |fact|
-        puts " #{fact.object} - #{fact.id} - #{fact.recency}"
-      end
-    end
-  end
-
-  # This is the core class of the library.  A new rule engine is created by 
-  # instantiating it.  Each rule engine has one inference engine, one rule set
-  # and one working memory.
-  class Engine        
-    
-    def initialize(wm=WorkingMemory.new,cr=RulebyConflictResolver.new)
-      @root = nil
-      @working_memory = wm
-      @conflict_resolver = cr
-      @wm_altered = false
-      assert InitialFact.new
-    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)
-      @wm_altered = true
-      fact_helper(object,:plus,&block)
-    end
-
-    # This method is called to remove an existing fact from working memory
-    def retract(object,&block)
-      @wm_altered = true
-      fact_helper(object,:minus,&block)
-    end
-
-    # This method is called to alter an existing fact.  It is essentially a 
-    # retract followed by an assert.
-    def modify(object,&block)
-      retract(object,&block)
-      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)         
-      if @root == nil
-        @root = RootNode.new(@working_memory) 
-        @root.reset_counter
-      end
-      @root.assert_rule rule
-    end
-    
-    # This method executes the activations that were generated by the rules
-    # that match facts in working memory.
-    def match(agenda=nil, used_agenda=[])      
-      if @root
-        @root.reset_counter
-        agenda = @root.matches unless agenda 
-        while (agenda.length > 0)
-          agenda = @conflict_resolver.resolve agenda            
-          activation = agenda.pop   
-          used_agenda.push activation     
-          activation.fire self   
-          if @wm_altered          
-            agenda = @root.matches(false)    
-            @root.increment_counter
-            @wm_altered = false
-          end
-        end
-      end
-    end
-    
-    def print
-      @working_memory.print
-      @root.print
-    end 
-    
-    private 
-      def fact_helper(object, sign=:plus, &block)
-        f = Core::Fact.new object, sign
-        yield f if block_given?
-        assert_fact f
-        f
-      end   
-      
-      def assert_fact(fact)
-        wm_fact = @working_memory.assert_fact fact      
-        @root.assert_fact wm_fact if @root != nil
-      end  
-  end  
-end
+# 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, Matt Smith
+#
+
+require 'core/atoms'
+require 'core/patterns'
+require 'core/utils'
+require 'core/nodes'
+
+module Ruleby
+  module Core
+  
+  # An action is a wrapper for a code block that will be executed if a rule is
+  # satisfied.  
+  class Action    
+    attr_accessor :priority
+    attr_accessor :name
+    attr_reader   :matches
+    attr_reader   :proc
+    
+    def initialize(&block)
+      @name = nil
+      @proc = Proc.new(&block) if block_given?
+      @priority = 0
+    end
+            
+    def fire(match, engine=nil)
+      if @proc.arity == 2
+        @proc.call(match, engine)
+      else
+        @proc.call(match)
+      end
+    end 
+       
+    def ==(a2)
+      return @name == a2.name
+    end    
+  end   
+ 
+  # An activation is an action/match pair that is executed if a rule is matched.
+  # It also contains metadata that can be used for conflict resolution if two 
+  # rules are satisfied by the same fact.
+  class Activation      
+    attr_reader   :action, :match
+    attr_accessor :counter, :used
+    
+    def initialize(action, match, counter=0)
+      @action = action
+      @match = match
+      @match.recency.sort!
+      @match.recency.reverse!
+      @counter = counter
+      @used = false
+    end   
+    
+    def fire(engine=nil)
+      @used = true
+      @action.fire @match, engine
+    end
+    
+    def <=>(a2)          
+      return @counter <=> a2.counter if @counter != a2.counter
+      return @action.priority <=> a2.action.priority if @action.priority != a2.action.priority           
+
+      # NOTE in order for this to work, the array must be reverse sorted
+      i = 0; while @match.recency[i] == a2.match.recency[i] && i < @match.recency.size-1 && i < a2.match.recency.size-1 
+        i += 1
+      end
+      return @match.recency[i] <=> a2.match.recency[i]
+    end
+    
+    def ==(a2)
+      return a2 != nil && @action == a2.action && @match == a2.match
+    end
+    
+    def to_s
+      return "[#{@action.name}-#{object_id}|#{@counter}|#{@action.priority}|#{@match.recency.join(',')}|#{@match.to_s}] "
+    end
+  end
+ 
+  class Rule  
+    attr_accessor :pattern
+    attr_reader   :action, :name, :priority   
+    
+    def initialize(name, pattern=nil, action=nil, priority=0) 
+      @name = name
+      @pattern = pattern
+      @action = action  
+      @priority = priority    
+    end
+    
+    def priority=(p)
+      @priority = p
+      @action.priority = @priority
+    end    
+  end
+  
+  # A fact is an object that is stored in working memory.  The rules in the 
+  # system will either look for the existence or absence of particular facts.
+  class Fact      
+    attr :token, true
+    attr :recency, true    
+    attr_reader :object
+    
+    def initialize(object, token)
+      @token = token      
+      @object = object
+    end
+       
+    def id
+      return object.object_id
+    end
+    
+    def ==(fact)
+      if fact.is_a? Fact
+        fact != nil && fact.id == id
+      else
+        fact != nil && fact.object_id == id
+      end
+    end
+    
+    def to_s
+      "[Fact |#{@recency}|#{@object.to_s}]"
+    end
+  end
+  
+  # A conflict resolver is used to order activations that become active at the 
+  # same time.  The default implementation sorts the agenda based on the 
+  # properties of the activation.
+  class RulebyConflictResolver   
+    def resolve(agenda) 
+      return agenda.sort
+    end    
+  end
+  
+  # The working memory is a container for all the facts in the system.  The
+  # 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
+    end
+    
+    def each_fact
+      @facts.each do |f|
+        yield(f)
+      end
+    end
+    
+    def assert_fact(fact)
+      raise 'The fact asserted cannot be nil!' unless fact.object
+      if (fact.token == :plus)
+        fact.recency = @recency
+        @recency += 1
+        @facts.push fact
+        return fact
+      else #if (fact.token == :minus)  
+        i = @facts.index(fact)
+        raise 'The fact to remove does not exist!' unless i
+        existing_fact = @facts[i]
+        @facts.delete_at(i)
+        existing_fact.token = fact.token
+        return existing_fact
+      end
+    end
+    
+    def print
+      puts 'WORKING MEMORY:'
+      @facts.each do |fact|
+        puts " #{fact.object} - #{fact.id} - #{fact.recency}"
+      end
+    end
+  end
+
+  # This is the core class of the library.  A new rule engine is created by 
+  # instantiating it.  Each rule engine has one inference engine, one rule set
+  # and one working memory.
+  class Engine        
+    
+    def initialize(wm=WorkingMemory.new,cr=RulebyConflictResolver.new)
+      @root = nil
+      @working_memory = wm
+      @conflict_resolver = cr
+      @wm_altered = false
+      assert InitialFact.new
+    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)
+      @wm_altered = true
+      fact_helper(object,:plus,&block)
+    end
+
+    # This method is called to remove an existing fact from working memory
+    def retract(object,&block)
+      @wm_altered = true
+      fact_helper(object,:minus,&block)
+    end
+
+    # This method is called to alter an existing fact.  It is essentially a 
+    # retract followed by an assert.
+    def modify(object,&block)
+      retract(object,&block)
+      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)         
+      if @root == nil
+        @root = RootNode.new(@working_memory) 
+        @root.reset_counter
+      end
+      @root.assert_rule rule
+    end
+    
+    # This method executes the activations that were generated by the rules
+    # that match facts in working memory.
+    def match(agenda=nil, used_agenda=[])      
+      if @root
+        @root.reset_counter
+        agenda = @root.matches unless agenda 
+        while (agenda.length > 0)
+          agenda = @conflict_resolver.resolve agenda            
+          activation = agenda.pop   
+          used_agenda.push activation     
+          activation.fire self   
+          if @wm_altered          
+            agenda = @root.matches(false)    
+            @root.increment_counter
+            @wm_altered = false
+          end
+        end
+      end
+    end
+    
+    def print
+      @working_memory.print
+      @root.print
+    end 
+    
+    private 
+      def fact_helper(object, sign=:plus, &block)
+        f = Core::Fact.new object, sign
+        yield f if block_given?
+        assert_fact f
+        f
+      end   
+      
+      def assert_fact(fact)
+        wm_fact = @working_memory.assert_fact fact      
+        @root.assert_fact wm_fact if @root != nil
+      end  
+  end  
+end
 end

data/lib/core/nodes.rb

@@ -200,7 +200,11 @@ module Ruleby
       end
       
       def create_bridge_node(pattern)
-        return BridgeNode.new(pattern)
+        if pattern.kind_of?(CollectPattern)
+          CollectNode.new(pattern)
+        else
+          BridgeNode.new(pattern)
+        end
       end
       
       def create_property_node(atom,forked)
@@ -483,12 +487,14 @@ module Ruleby
   # 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 
+  class BaseBridgeNode < ParentNode
     def initialize(pattern)
       super()
       @pattern =  pattern
     end
-  
+  end
+
+  class BridgeNode < BaseBridgeNode
     def propagate_assert(fact)          
       # create the partial match
       mr = MatchResult.new
@@ -505,7 +511,72 @@ module Ruleby
       end
       super(MatchContext.new(fact,mr))
     end
-  end  
+  end
+
+  class CollectNode < BaseBridgeNode
+    def initialize(pattern)
+      super
+      @collection_memory = Fact.new([], :internal)
+      @should_modify = false
+      # not really sure what to do about this. might just need to handle nil's
+      # using a puts a limit on how many facts can be asserted before this feature breaks
+      # it might be best to get a handle to WorkingMemory in order to get the real
+#      @collection_memory.recency = 0
+    end
+
+    def retract(fact)
+      propagate_retract(@collection_memory)
+      propagate_assert(fact) do
+        @collection_memory.object.delete_if {|a| a == fact.object}
+        @should_modify = false
+      end
+    end
+
+    def propagate_modify(context, out_nodes=@out_nodes)
+      out_nodes.each do |out_node|
+        if out_node.is_a?(TerminalNode)
+          out_node.modify(context)
+        else
+          raise "You can't join to :collect patterns yet!"
+        end
+      end
+    end
+
+    def propagate_assert(fact)
+      if block_given?
+        yield fact
+      else
+        @collection_memory.object << fact
+        @collection_memory.recency = fact.recency
+      end
+
+      if @should_modify
+        propagate_modify(MatchContext.new(@collection_memory, create_match_result))
+      else
+        if @collection_memory.object.size > 0
+          @should_modify = true
+          super(MatchContext.new(@collection_memory, create_match_result))
+        end
+      end
+    end
+
+    private
+
+    def create_match_result()
+      # create the partial match
+      mr = MatchResult.new
+      mr.is_match = true
+      mr.recency.push @collection_memory.recency
+
+      @pattern.atoms.each do |atom|
+        mr.fact_hash[atom.tag] = @collection_memory.id
+        if atom == @pattern.head
+          mr[atom.tag] = @collection_memory.object
+        end
+      end
+      mr
+    end
+  end
     
   # This class is used to plug nodes into the left input of a two-input JoinNode
   class LeftAdapterNode < ParentNode
@@ -549,7 +620,7 @@ module Ruleby
       end
     end
   end
-  
+
   # 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.  These nodes make up what is called
@@ -740,13 +811,30 @@ module Ruleby
       @rule = rule
       @activations = MultiHash.new  
     end
-    attr_reader:activations
-  
+    #attr_reader:activations
+
+    def activations
+      @activations
+    end
+
     def assert(context)
       match = context.match
       a = Activation.new(@rule.action, match, @@counter)
       @activations.add match.fact_ids, a
     end
+
+    def modify(context)
+      found = false
+      @activations.each do |id, v|
+        if context.match.fact_ids.sort == id.sort
+          v.replace(context.fact)
+          found = true
+        end
+      end
+      if !found
+        assert(context)
+      end
+    end
     
     def retract(fact)
       @activations.remove fact.id

data/lib/core/patterns.rb

@@ -1,116 +1,119 @@
-# 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
-
-  class Pattern
-  end
-  
-  # This class represents a pattern that is looking for the existence of some
-  # object. It contains a list of 'atoms' that represent the properties of
-  # the class that we are looking for.
-  class ObjectPattern < Pattern
-    attr_reader :atoms
-    
-    def initialize(head, atoms)
-      @atoms = [head] + atoms     
-    end
-    
-    def head
-      @atoms[0]
-    end      
-    
-    def ==(pattern)
-      if pattern.class == self.class
-        atoms = pattern.atoms
-        if(@atoms.size == atoms.size)
-          (0..@atoms.size).each do |i|
-            if !(@atoms[i] == atoms[i])
-              return false
-            end
-          end
-          return true
-        end
-      end
-      return false
-    end
-   
-    def to_s
-      return '(' + @atoms.join('|') + ')'
-    end
-  end
-  
-  class InheritsPattern < ObjectPattern
-  end
-  
-  # This class represents a pattern that is looking for the absence of some
-  # object (rather than the existence of).  In all respects, it is the same as
-  # an ObjectPattern, but it is handled differently by the inference engine.
-  class NotPattern < ObjectPattern
-  end
-  
-  class NotInheritsPattern < InheritsPattern
-  end
-  
-  # A composite pattern represents a logical conjunction of two patterns.  The
-  # inference engine interprets this differently from an ObjectPattern because
-  # it simply aggregates patterns.  
-  class CompositePattern < Pattern
-        
-    attr_reader :left_pattern
-    attr_reader :right_pattern
-    
-    def initialize(left_pattern, right_pattern)
-      @left_pattern = left_pattern
-      @right_pattern = right_pattern
-    end    
-    
-    def atoms
-      atoms = []
-      atoms.push @left_pattern.atoms
-      atoms.push @right_pattern.atoms
-      return atoms
-    end
-  end
-  
-  class AndPattern < CompositePattern
-  
-    def initialize(left_pattern, right_pattern)
-      super(left_pattern, right_pattern)
-      @head = :and    
-    end
-     
-  end
-  
-  class OrPattern < CompositePattern
-    
-    def initialize(left_pattern, right_pattern)
-      super(left_pattern, right_pattern)
-      @head = :or
-    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
+# 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
+
+  class Pattern
+  end
+  
+  # This class represents a pattern that is looking for the existence of some
+  # object. It contains a list of 'atoms' that represent the properties of
+  # the class that we are looking for.
+  class ObjectPattern < Pattern
+    attr_reader :atoms
+    
+    def initialize(head, atoms)
+      @atoms = [head] + atoms     
+    end
+    
+    def head
+      @atoms[0]
+    end      
+    
+    def ==(pattern)
+      if pattern.class == self.class
+        atoms = pattern.atoms
+        if(@atoms.size == atoms.size)
+          (0..@atoms.size).each do |i|
+            if !(@atoms[i] == atoms[i])
+              return false
+            end
+          end
+          return true
+        end
+      end
+      return false
+    end
+   
+    def to_s
+      return '(' + @atoms.join('|') + ')'
+    end
+  end
+  
+  class InheritsPattern < ObjectPattern
+  end
+
+  class CollectPattern < ObjectPattern    
+  end
+  
+  # This class represents a pattern that is looking for the absence of some
+  # object (rather than the existence of).  In all respects, it is the same as
+  # an ObjectPattern, but it is handled differently by the inference engine.
+  class NotPattern < ObjectPattern
+  end
+  
+  class NotInheritsPattern < InheritsPattern
+  end
+  
+  # A composite pattern represents a logical conjunction of two patterns.  The
+  # inference engine interprets this differently from an ObjectPattern because
+  # it simply aggregates patterns.  
+  class CompositePattern < Pattern
+        
+    attr_reader :left_pattern
+    attr_reader :right_pattern
+    
+    def initialize(left_pattern, right_pattern)
+      @left_pattern = left_pattern
+      @right_pattern = right_pattern
+    end    
+    
+    def atoms
+      atoms = []
+      atoms.push @left_pattern.atoms
+      atoms.push @right_pattern.atoms
+      return atoms
+    end
+  end
+  
+  class AndPattern < CompositePattern
+  
+    def initialize(left_pattern, right_pattern)
+      super(left_pattern, right_pattern)
+      @head = :and    
+    end
+     
+  end
+  
+  class OrPattern < CompositePattern
+    
+    def initialize(left_pattern, right_pattern)
+      super(left_pattern, right_pattern)
+      @head = :or
+    end
+
+  end
+  
+  class InitialFactPattern < ObjectPattern
+    def initialize
+      deftemplate = Template.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/dsl/ferrari.rb

@@ -216,12 +216,15 @@ module Ruleby
       def when(*args)      
         clazz = AtomBuilder === args[0] ? nil : args.shift
         is_not = false
+        is_collect = false
         mode = :equals
         while clazz.is_a? Symbol          
           if clazz == :not || clazz == :~
             is_not = true
           elsif clazz == :is_a? || clazz == :kind_of? || clazz == :instance_of?
             mode = :inherits
+          elsif clazz == :collect
+            is_collect = true
           elsif clazz == :exists?
             raise 'The \'exists\' quantifier is not yet supported.'
           end
@@ -233,7 +236,7 @@ module Ruleby
           mode = :inherits
         end
 
-        deftemplate = Core::DefTemplate.new clazz, mode        
+        deftemplate = Core::Template.new clazz, mode
         atoms = []
         @when_counter += 1
         htag = Symbol === args[0] ? args.shift : GeneratedTag.new
@@ -259,14 +262,15 @@ module Ruleby
           else
             raise "Invalid condition: #{arg}"
           end
-        end  
+        end
 
         if is_not 
           p = mode==:inherits ? Core::NotInheritsPattern.new(head, atoms) : 
                                 Core::NotPattern.new(head, atoms)
         else
           p = mode==:inherits ? Core::InheritsPattern.new(head, atoms) : 
-                                Core::ObjectPattern.new(head, atoms)
+                                is_collect ? Core::CollectPattern.new(head, atoms) :
+                                             Core::ObjectPattern.new(head, atoms)
         end
         @pattern = @pattern ? Core::AndPattern.new(@pattern, p) : p
       end
@@ -293,6 +297,8 @@ module Ruleby
 
     class MethodBuilder  
       public_instance_methods.each do |m|
+        # maybe we shouldn't be undefing object_id.  What are the implications?  Can we make object_id a
+        # pass through to the underlying object's object_id?
         a = [:method_missing, :new, :public_instance_methods, :__send__, :__id__]
         undef_method m.to_sym unless a.include? m.to_sym
       end
@@ -318,31 +324,31 @@ module Ruleby
         @tag = tag
         @method = method
       end
-      
+
       def +(arg)
         raise 'Cannot use operators in short-hand mode!'
       end
-      
+
       def -(arg)
         raise 'Cannot use operators in short-hand mode!'
       end
-      
+
       def /(arg)
         raise 'Cannot use operators in short-hand mode!'
       end
-      
+
       def *(arg)
         raise 'Cannot use operators in short-hand mode!'
       end
-      
+
       def to_s
         "BindingBuilder @tag=#{@tag}, @method=#{@method}"
       end
     end
-    
+
     class AtomBuilder
       attr_accessor :tag, :name, :bindings, :deftemplate, :block
-      
+
       def initialize(method_id)
         @name = method_id
         @deftemplate = nil
@@ -351,39 +357,48 @@ module Ruleby
         @block = lambda {|x| true}
         @child_atom_builders = []
       end
-      
+
       def method_missing(method_id, *args, &block)
         if method_id == :not
           return NotOperatorBuilder.new(@name)
         end
       end
-      
+
       def ==(value)
         @atom_type = :equals
         @value = value
-        create_block value, lambda {|x,y| x == y}, lambda {|x| x == value}; self
+        create_block value, lambda {|x,y| convert(x, y) == y}, lambda {|x| convert(x, value) == value}; self
       end
-      
+
       def >(value)
-        create_block value, lambda {|x,y| x > y}, lambda {|x| x > value}; self
+        create_block value, lambda {|x,y| x != nil && convert(x, y) > y}, lambda {|x| x != nil && convert(x, value) > value}; self
       end
-      
+
       def <(value)
-        create_block value, lambda {|x,y| x < y}, lambda {|x| x < value}; self
+        create_block value, lambda {|x,y| x != nil && convert(x, y) < y}, lambda {|x| x != nil && convert(x, value) < value}; self
       end
-      
+
       def =~(value)
-        create_block value, lambda {|x,y| x =~ y}, lambda {|x| x =~ value}; self
+        create_block value, lambda {|x,y| convert(x, y) =~ y}, lambda {|x| convert(x, value) =~ value}; self
       end
-      
+
       def <=(value)
-        create_block value, lambda {|x,y| x <= y}, lambda {|x| x <= value}; self
+        create_block value, lambda {|x,y| x != nil && convert(x, y) <= y}, lambda {|x| x != nil && convert(x, value) <= value}; self
       end
-      
+
       def >=(value)
-        create_block value, lambda {|x,y| x >= y}, lambda {|x| x >= value}; self
+        create_block value, lambda {|x,y| x != nil && convert(x, y) >= y}, lambda {|x| x != nil && convert(x, value) >= value}; self
       end 
-      
+
+      def convert(x, value)
+        if x.nil?
+          return x
+        end
+        return x.to_f if value.kind_of? Float
+        return x.to_i if value.kind_of? Numeric
+        return x
+      end 
+
       def build_atoms(tags,methods,when_id)
         atoms = @child_atom_builders.map { |atom_builder|
           tags[atom_builder.tag] = when_id
@@ -398,7 +413,7 @@ module Ruleby
             return atoms << Core::PropertyAtom.new(@tag, @name, @deftemplate, &@block)
           end
         end
-        
+
         if references_self?(tags,when_id)
           bind_methods = @bindings.collect{ |bb| methods[bb.tag] }
           atoms << Core::SelfReferenceAtom.new(@tag,@name,bind_methods,@deftemplate,&@block)
@@ -407,7 +422,7 @@ module Ruleby
           atoms << Core::ReferenceAtom.new(@tag,@name,bind_tags,@deftemplate,&@block)
         end
       end
-      
+
       private
       def references_self?(tags,when_id)
         ref_self = 0
@@ -416,14 +431,14 @@ module Ruleby
             ref_self += 1
           end
         end
-        
+
         if ref_self > 0 and ref_self != @bindings.size
           raise 'Binding to self and another pattern in the same condition is not yet supported.'
         end
-        
+
         return ref_self > 0
       end
-      
+
       def create_block(value, ref_block, basic_block)
         if value && value.kind_of?(BindingBuilder)
           @bindings = [value]
@@ -437,7 +452,7 @@ module Ruleby
         end
       end
     end
-    
+
     class NotOperatorBuilder < AtomBuilder
       def ==(value)
         create_block value, lambda {|x,y| x != y}, lambda {|x| x != value}; self

data/lib/dsl/letigre.rb

@@ -136,7 +136,7 @@ module Ruleby
             mode = :inherits
           end
           
-          deftemplate = Core::DefTemplate.new clazz, mode
+          deftemplate = Core::Template.new clazz, mode
           head = Core::HeadAtom.new tag, deftemplate
 
           atoms = []      

metadata

@@ -1,16 +1,21 @@
 --- !ruby/object:Gem::Specification 
 name: ruleby
 version: !ruby/object:Gem::Version 
-  version: "0.7"
+  prerelease: true
+  segments: 
+    - 0
+    - 8
+    - b1
+  version: 0.8.b1
 platform: ruby
 authors: 
-- Joe Kutner
-- Matt Smith
+  - Joe Kutner
+  - Matt Smith
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-08-27 00:00:00 -05:00
+date: 2011-03-29 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -28,17 +33,17 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/core/atoms.rb
-- lib/core/engine.rb
-- lib/core/nodes.rb
-- lib/core/patterns.rb
-- lib/core/utils.rb
-- lib/dsl/ferrari.rb
-- lib/dsl/letigre.rb
-- lib/dsl/steel.rb
-- lib/rule_helper.rb
-- lib/rulebook.rb
-- lib/ruleby.rb
+  - lib/rule_helper.rb
+  - lib/rulebook.rb
+  - lib/ruleby.rb
+  - lib/core/atoms.rb
+  - lib/core/engine.rb
+  - lib/core/nodes.rb
+  - lib/core/patterns.rb
+  - lib/core/utils.rb
+  - lib/dsl/ferrari.rb
+  - lib/dsl/letigre.rb
+  - lib/dsl/steel.rb
 has_rdoc: true
 homepage: http://ruleby.org
 licenses: []
@@ -47,25 +52,31 @@ post_install_message:
 rdoc_options: []
 
 require_paths: 
-- lib
+  - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
   requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: 1.8.2
-  version: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 1
+          - 8
+          - 2
+        version: 1.8.2
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 1
+          - 3
+          - 1
+        version: 1.3.1
 requirements: []
 
 rubyforge_project: ruleby
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Rete based Ruby Rule Engine
 test_files: 
-- tests/test.rb
+  - tests/test.rb