ruleby 0.8.b1 → 0.8.b2

data/lib/core/engine.rb

@@ -79,6 +79,11 @@ module Ruleby
     def ==(a2)
       return a2 != nil && @action == a2.action && @match == a2.match
     end
+
+    def modify(match)
+      @match = match
+      # should we update recency, too? 
+    end
     
     def to_s
       return "[#{@action.name}-#{object_id}|#{@counter}|#{@action.priority}|#{@match.recency.join(',')}|#{@match.to_s}] "

data/lib/core/nodes.rb

@@ -324,6 +324,16 @@ module Ruleby
         out_node.assert(assertable)
       end
     end
+
+    def modify(assertable)
+      raise "Modify not supported by default - its only used for :collect.  This must be a bug"
+    end
+
+    def propagate_modify(assertable,out_nodes=@out_nodes)
+      out_nodes.each do |out_node|
+        out_node.modify(assertable)
+      end
+    end
   end
   
   # This is a base class for all single input nodes that match facts based on
@@ -532,16 +542,6 @@ module Ruleby
       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
@@ -597,6 +597,12 @@ module Ruleby
         o.retract_resolve(match)
       end
     end
+
+    def modify(context)
+      @out_nodes.each do |out_node|
+        out_node.modify_left(context)
+      end
+    end
   end
   
   # This class is used to plug nodes into the right input of a two-input 
@@ -619,6 +625,12 @@ module Ruleby
         o.retract_resolve(match)
       end
     end
+
+    def modify(context)
+      @out_nodes.each do |out_node|
+        out_node.modify_right(context)
+      end
+    end
   end
 
   # This class is a two-input node that is used to create a cross-product of the
@@ -666,7 +678,23 @@ module Ruleby
           propagate_assert(new_context)
         end
       end
-    end    
+    end
+
+    def modify_left(context)
+      @left_memory[context.fact.id] = [context]
+      # you can't ref :collect patterns, so there should be anything to do on the right-memory
+      #propagate_modify(context)
+
+      # TODO something needs to happen here - but i'm not sure what!
+    end
+
+    def modify_right(context)
+      @right_memory[context.fact.id] = context
+      # you can't ref :collect patterns, so there should be anything to do on the left-memory
+      #propagate_modify(context)
+
+      # TODO something needs to happen here - but i'm not sure what!
+    end
         
     def to_s
       return "#{self.class}:#{object_id} | #{@left_memory.values} | #{@right_memory}"
@@ -723,8 +751,7 @@ module Ruleby
   
   # This node class is used when a rule is looking for a fact that does not 
   # exist.  It is a two-input node, and thus has some of the properties of the
-  # JoinNode.  NOTE it has not clear how this will work if the NotPattern is
-  # declared as the first pattern in a rule.
+  # JoinNode.
   class NotNode < JoinNode
     def initialize
       super
@@ -770,7 +797,7 @@ module Ruleby
       end
     end
     
-    def assert_right(context)                    
+    def assert_right(context)
       @right_memory[context.fact.id] = context
       if @ref_nodes.empty?
         @left_memory.values.flatten.each do |left_context|
@@ -785,7 +812,7 @@ module Ruleby
         end
       end
     end
-    
+
     # NOTE this returns a boolean, while the other classes return a MatchResult
     def match_ref_nodes(left_context,right_context)
       @ref_nodes.each do |ref_node|
@@ -827,11 +854,11 @@ module Ruleby
       found = false
       @activations.each do |id, v|
         if context.match.fact_ids.sort == id.sort
-          v.replace(context.fact)
+          v.modify(context.match)
           found = true
         end
       end
-      if !found
+      if !found and context.match.is_match
         assert(context)
       end
     end

data/lib/dsl/ferrari.rb

@@ -324,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
@@ -357,48 +357,39 @@ 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| convert(x, y) == y}, lambda {|x| convert(x, value) == value}; self
+        create_block value, lambda {|x,y| x == y}, lambda {|x| x == value}; self
       end
-
+      
       def >(value)
-        create_block value, lambda {|x,y| x != nil && convert(x, y) > y}, lambda {|x| x != nil && convert(x, value) > value}; self
+        create_block value, lambda {|x,y| x > y}, lambda {|x| x > value}; self
       end
-
+      
       def <(value)
-        create_block value, lambda {|x,y| x != nil && convert(x, y) < y}, lambda {|x| x != nil && convert(x, value) < value}; self
+        create_block value, lambda {|x,y| x < y}, lambda {|x| x < value}; self
       end
-
+      
       def =~(value)
-        create_block value, lambda {|x,y| convert(x, y) =~ y}, lambda {|x| convert(x, value) =~ value}; self
+        create_block value, lambda {|x,y| x =~ y}, lambda {|x| x =~ value}; self
       end
-
+      
       def <=(value)
-        create_block value, lambda {|x,y| x != nil && convert(x, y) <= y}, lambda {|x| x != nil && convert(x, value) <= value}; self
+        create_block value, lambda {|x,y| x <= y}, lambda {|x| x <= value}; self
       end
-
+      
       def >=(value)
-        create_block value, lambda {|x,y| x != nil && convert(x, y) >= y}, lambda {|x| x != nil && convert(x, value) >= value}; self
+        create_block value, lambda {|x,y| x >= y}, lambda {|x| x >= 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
@@ -413,7 +404,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)
@@ -422,7 +413,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
@@ -431,14 +422,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]
@@ -452,7 +443,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/rulebook.rb

@@ -67,7 +67,7 @@ module Ruleby
     # string that is unique for each instance of this class.
     @@tag_counter = 0
 
-    # every generated tag will be prefixed with this string
+    # every generated tag will be prefixed with this string.  This isn't full-proof.
     @@unique_seed = 'unique_seed'
 
     def initialize()

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
     - 0
     - 8
-    - b1
-  version: 0.8.b1
+    - b2
+  version: 0.8.b2
 platform: ruby
 authors: 
   - Joe Kutner
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-29 00:00:00 -05:00
+date: 2011-04-07 00:00:00 -05:00
 default_executable: 
 dependencies: []