ruleby 0.9.b4 → 0.9.b7

data/examples/ticket.rb

@@ -0,0 +1,113 @@
+# 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
+#
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '../lib/')
+require 'ruleby'
+
+include Ruleby
+
+class Customer
+  def initialize(name,subscription)
+    @name = name
+    @subscription = subscription
+  end
+  attr_reader :name,:subscription
+  def to_s
+    return '[Customer ' + @name.to_s + ' : ' + @subscription.to_s + ']';
+  end
+end
+
+class Ticket
+  def initialize(customer)
+    @customer = customer
+    @status = :New
+  end
+  attr :status, true
+  attr_reader :customer
+  def to_s
+    return '[Ticket ' + @customer.to_s + ' : ' + @status.to_s + ']';
+  end
+end
+
+# This example is used in JBoss-Rules to demonstrate durations and the use of
+# custom DSL.  We are simply using it here to demonstrate another example.
+class TroubleTicketRulebook < Rulebook
+  def rules
+  
+    # This is uses the letigre syntax... but we can mix and match syntaxes in 
+    # the same rule set.
+    rule :New_Ticket, {:priority => 10}, # :duration => 10},
+      [Customer, :c],
+      [Ticket, :ticket, {m.customer => :c}, m.status == :New] do |vars|
+        puts 'New : ' + vars[:ticket].to_s
+    end
+    
+    # Now we are using the ferrari syntax.  The rule method can detect which 
+    # syntax we are using, and compile accordingly.
+    rule :Silver_Priority, #{:duration => 3000},
+      [Customer, :customer, m.subscription == 'Silver'],
+      [Ticket,:ticket, m.customer == b(:customer), m.status == :New] do |vars|
+        vars[:ticket].status = :Escalate
+        modify vars[:ticket]
+    end
+    
+    rule :Gold_Priority, #{:duration => 1000},
+      [Customer, :customer, m.subscription == 'Gold'],
+      [Ticket,:ticket, m.customer == b(:customer), m.status == :New] do |vars|
+        vars[:ticket].status = :Escalate
+        modify vars[:ticket]
+    end
+    
+    rule :Platinum_Priority,
+      [Customer, :customer, m.subscription == 'Platinum'],
+      [Ticket,:ticket, m.customer == b(:customer), m.status == :New] do |vars|
+        vars[:ticket].status = :Escalate
+        modify vars[:ticket]
+    end
+    
+    rule :Escalate,
+      [Customer, :c],
+      [Ticket, :ticket, {m.customer => :c}, m.status == :Escalate] do |vars|
+        puts 'Email : ' + vars[:ticket].to_s    
+    end
+    
+    rule :Done,
+      [Customer, :c],
+      [Ticket, :ticket, {m.customer => :c}, m.status == :Done] do |vars|
+        puts 'Done : ' + vars[:ticket].to_s
+    end
+  end
+end
+
+# FACTS
+
+a = Customer.new('A', 'Gold')
+b = Customer.new('B', 'Platinum')
+c = Customer.new('C', 'Silver')
+d = Customer.new('D', 'Silver')
+
+t1 = Ticket.new(a)
+t2 = Ticket.new(b)
+t3 = Ticket.new(c)
+t4 = Ticket.new(d)
+
+engine :engine do |e|
+  TroubleTicketRulebook.new(e).rules
+  e.assert a
+  e.assert b
+  e.assert c
+  e.assert d
+  e.assert t1
+  e.assert t2
+  e.assert t3
+  e.assert t4
+  e.match
+end

data/examples/wordgame.rb

@@ -0,0 +1,107 @@
+# 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
+#
+
+
+# This example solves the number puzzle problem where
+#    GERALD 
+#  + DONALD
+#    ------
+#  = ROBERT
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '../lib/')
+require 'ruleby'
+
+include Ruleby
+
+class Combination
+  attr:a
+  attr:x
+  def initialize(a,x)
+    @a = a
+    @x = x
+  end
+end
+
+class WordGameRulebook < Ruleby::Rulebook
+  def rules
+    rule :generate_combos, [String, :a], [Fixnum, :x] do |v|
+      assert Combination.new(v[:a], v[:x])
+    end
+    
+    c1 = c{|t,d| ((d+d) % 10) == t }    
+    c2 = c{|r,d,t,l| ((d+d+(10*l)+(10*l)) % 100) == ((10 * r) + t) }
+    c3 = c{|e,d,l,a,r,t| ((d+d+(10*l)+(10*l)+(100*a)+(100*a)) % 1000) == ((100*e)+(10*r)+t) }
+    c4 = c{|b,d,l,a,r,n,e,t| ((d+d+(10*l)+(10*l)+(100*a)+(100*a)+(1000*r)+(1000*n)) % 10000) == ((1000*b)+(100*e)+(10*r)+t) }
+    c5 = c{|g,d,l,a,r,n,e,o,b,t| (d+d+(10*l)+(10*l)+(100*a)+(100*a)+(1000*r)+(1000*n)+(10000*e)+(10000*o)+(100000*g)+(100000*d)) == ((100000*r)+(10000*o)+(1000*b)+(100*e)+(10*r)+t) }
+ 
+    rule :find_solution, 
+        [Combination, m.a=='D', {m.x => :d}],
+        [Combination, m.a=='T', {m.x.not==b(:d)=>:t}, m.x(:d, &c1)],      
+        [Combination, m.a=='L', {m.x.not==b(:d)=>:l}, m.x.not==b(:t)],
+        [Combination, m.a=='R', {m.x.not==b(:d)=>:r}, m.x.not==b(:t), m.x.not==b(:l), 
+          m.x(:d,:t,:l, &c2)],
+        [Combination, m.a=='A', {m.x.not==b(:d)=>:a}, m.x.not==b(:t), m.x.not==b(:l), m.x.not==b(:r)],
+        [Combination, m.a=='E', {m.x.not==b(:d)=>:e}, m.x.not==b(:t), m.x.not==b(:l), m.x.not==b(:r), 
+          m.x.not==b(:a), m.x(:d,:l,:a,:r,:t, &c3)],
+        [Combination, m.a=='N', {m.x.not==b(:d)=>:n}, m.x.not==b(:t), m.x.not==b(:l), m.x.not==b(:r), 
+          m.x.not==b(:a), m.x.not==b(:e)],
+        [Combination, m.a=='B', {m.x.not==b(:d)=>:b}, m.x.not==b(:t), m.x.not==b(:l), m.x.not==b(:r), 
+          m.x.not==b(:a), m.x.not==b(:e), m.x.not==b(:n), m.x(:d,:l,:a,:r,:n,:e,:t, &c4)],    
+        [Combination, m.a=='O', {m.x.not==b(:d)=>:o}, m.x.not==b(:t), m.x.not==b(:l), m.x.not==b(:r), 
+          m.x.not==b(:a), m.x.not==b(:e), m.x.not==b(:n), m.x.not==b(:b)],    
+        [Combination, m.a=='G', {m.x.not==b(:d)=>:g}, m.x.not==b(:t), m.x.not==b(:l), m.x.not==b(:r), 
+          m.x.not==b(:a), m.x.not==b(:e), m.x.not==b(:n), m.x.not==b(:b), m.x.not==b(:o), 
+          m.x(:d,:l,:a,:r,:n,:e,:o,:b,:t, &c5)] do |v|
+      puts "One Solution is:"
+      puts "  G = #{v[:g]}"
+      puts "  E = #{v[:e]}"
+      puts "  R = #{v[:r]}" 
+      puts "  A = #{v[:a]}" 
+      puts "  L = #{v[:l]}"
+      puts "  D = #{v[:d]}"
+      puts "  O = #{v[:o]}"
+      puts "  N = #{v[:n]}"
+      puts "  B = #{v[:b]}"
+      puts "  T = #{v[:t]}"
+      puts ""
+      puts "   #{v[:g]} #{v[:e]} #{v[:r]} #{v[:a]} #{v[:l]} #{v[:d]}"
+      puts " + #{v[:d]} #{v[:o]} #{v[:n]} #{v[:a]} #{v[:l]} #{v[:d]}"
+      puts "   ------"
+      puts " = #{v[:r]} #{v[:o]} #{v[:b]} #{v[:e]} #{v[:r]} #{v[:t]}"
+    end
+  end
+end
+
+e = engine :e do |e|
+  WordGameRulebook.new(e).rules
+  e.assert 0
+  e.assert 1
+  e.assert 2
+  e.assert 3
+  e.assert 4
+  e.assert 5
+  e.assert 6
+  e.assert 7
+  e.assert 8
+  e.assert 9
+  e.assert 'G'
+  e.assert 'E'
+  e.assert 'R'
+  e.assert 'A'
+  e.assert 'L'
+  e.assert 'D'
+  e.assert 'O'
+  e.assert 'N'
+  e.assert 'B'
+  e.assert 'T'
+end
+
+e.match

data/lib/core/engine.rb

@@ -73,11 +73,11 @@ module Ruleby
       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]
+      @match.recency[i] <=> a2.match.recency[i]
     end
     
     def ==(a2)
-      return a2 != nil && @action == a2.action && @match == a2.match
+      a2 != nil && @action == a2.action && @match == a2.match
     end
 
     def modify(match)
@@ -110,12 +110,10 @@ module Ruleby
   # 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 :recency, true
     attr_reader :object
     
-    def initialize(object, token)
-      @token = token      
+    def initialize(object)
       @object = object
     end
        
@@ -163,20 +161,19 @@ module Ruleby
     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
+      raise 'The fact asserted cannot be nil!' if fact.object.nil?
+      fact.recency = @recency
+      @recency += 1
+      @facts.push fact
+      return fact
+    end
+
+    def retract_fact(fact)
+      i = @facts.index(fact)
+      raise 'The fact to remove does not exist!' unless i
+      existing_fact = @facts[i]
+      @facts.delete_at(i)
+      return existing_fact
     end
     
     def print
@@ -281,17 +278,22 @@ module Ruleby
     end 
     
     private 
-      def fact_helper(object, sign=:plus, &block)
-        f = Core::Fact.new object, sign
+      def fact_helper(object, sign=:plus)
+        f = Core::Fact.new object
         yield f if block_given?
-        assert_fact f
+        sign==:plus ? assert_fact(f) : retract_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
+
+      def retract_fact(fact)
+        wm_fact = @working_memory.retract_fact fact
+        @root.retract_fact wm_fact if @root != nil
+      end
   end  
 end
 end

data/lib/core/nodes.rb

@@ -34,14 +34,16 @@ module Ruleby
       @terminal_nodes.push terminal_node
     end    
             
-    # When a new fact is added to working memory, or an existing one is removed
-    # this method is called.  It finds any nodes that depend on it, and updates
-    # them accordingly.
+    # When a new fact is added to working memory this method is called.  It finds any nodes that depend on it, and
+    # updates them accordingly.
     def assert_fact(fact) 
-      @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
+      @type_node.assert(fact) if @type_node
+      @inherit_nodes.each {|node| node.assert(fact) }
+    end
+
+    def retract_fact(fact)
+      @type_node.retract(fact) if @type_node
+      @inherit_nodes.each {|node| node.retract(fact) }
     end
         
     # Increments the activation counter.  This is just a pass-thru to the static 
@@ -459,34 +461,67 @@ module Ruleby
       end
     end
   end
+
+  class AlphaMemoryNode < AtomNode
+    def initialize(bucket, atom)
+      super(bucket, atom)
+      @memory = Hash.new(DEFAULT)
+    end
+
+    def retract(assertable)
+      forget(assertable)
+      super
+    end
+
+    def remember(assertable)
+      @memory[assertable.fact.object_id]
+    end
+
+    def memorized?(assertable)
+      @memory[assertable.fact.object_id] != DEFAULT
+    end
+
+    def memorize(assertable, value)
+      @memory[assertable.fact.object_id] = value
+    end
+
+    def forget(assertable)
+      @memory.delete(assertable.fact.object_id)
+    end
+  end
   
   # This node class is used for matching properties of a fact.
-  class PropertyNode < AtomNode
+  class PropertyNode < AlphaMemoryNode
     def assert(assertable)
-      begin
-        v = assertable.fact.object.send(@atom.slot)
-        assertable.add_tag(@atom.tag, v)
-      rescue NoMethodError => e
-        @bucket.add_error Error.new(:no_method, :warn, {
-            :object => assertable.fact.object.to_s,
-            :method => e.name,
-            :message => e.message
-        })
-        return
-      end
-      begin
-        if @atom.proc.arity == 1
-          super if @atom.proc.call(v)
-        else
-          super if @atom.proc.call(v, @atom.value)
+      unless memorized?(assertable)
+        begin
+          v = assertable.fact.object.send(@atom.slot)
+          assertable.add_tag(@atom.tag, v)
+          begin
+            if @atom.proc.arity == 1
+              r = @atom.proc.call(v)
+            else
+              r = @atom.proc.call(v, @atom.value)
+            end
+            memorize(assertable, r)
+            super if r
+          rescue Exception => e
+            @bucket.add_error Error.new(:proc_call, :error, {
+                :object => assertable.fact.object.to_s,
+                :method => @atom.slot,
+                :value => v.to_s,
+                :message => e.message
+            })
+          end
+        rescue NoMethodError => e
+          @bucket.add_error Error.new(:no_method, :warn, {
+              :object => assertable.fact.object.to_s,
+              :method => e.name,
+              :message => e.message
+          })
         end
-      rescue Exception => e
-        @bucket.add_error Error.new(:proc_call, :error, {
-            :object => assertable.fact.object.to_s,
-            :method => @atom.slot,
-            :value => v.to_s,
-            :message => e.message
-        })
+      else
+        super if remember(assertable)
       end
     end
   end
@@ -501,10 +536,13 @@ module Ruleby
   end  
   
   # This node class is used conditions that are simply a function, which returns true or false.
-  class FunctionNode < AtomNode
+  class FunctionNode < AlphaMemoryNode
     def assert(assertable)
       begin
-        super if @atom.proc.call(assertable.fact.object, *@atom.arguments)
+        unless memorized?(assertable)
+          memorize(assertable, @atom.proc.call(assertable.fact.object, *@atom.arguments))
+        end
+        super if remember(assertable)
       rescue Exception => e
         @bucket.add_error Error.new(:proc_call, :error, {
             :object => fact.object.to_s,
@@ -546,7 +584,7 @@ module Ruleby
             :message => e.message
         })
       end
-      return MatchResult.new
+      MatchResult.new
     end  
   end
   
@@ -611,7 +649,7 @@ module Ruleby
   class CollectNode < BaseBridgeNode
     def initialize(bucket, pattern)
       super
-      @collection_memory = Fact.new([], :internal)
+      @collection_memory = Fact.new([])
       @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
@@ -1001,5 +1039,9 @@ module Ruleby
     end
   end
 
+  class MemoryDefault
+  end
+  DEFAULT = MemoryDefault.new
+
   end
 end