ruleby 0.1 → 0.2

data/examples/example_ticket.rb

@@ -0,0 +1,158 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), '../lib/')
+require 'ruleby'
+require 'rulebook'
+
+# NOTE : before we can get this example working we need to figure out exactly 
+# what the conflict resolution strategy should be.  When we implement the 
+# default strategy as we understand it (from various literature) this example
+# does not work (nor should it).  But this example works in drools as is.  Why?
+
+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 here to demonstrate another example.
+class TroubleTicketRulebook < Rulebook
+  def rules
+    rule 'New Ticket' do |r|
+      r.when do |has|
+        has.customer Customer
+        has.ticket Ticket
+        has.ticket.customer = :customer, :%
+        has.ticket.status = 'New'
+      end
+      
+      r.then = action do |e,vars|
+        puts 'New : ' + vars[:ticket].to_s
+      end
+      
+      r.priority = 10  
+      #r.duration = 10
+    end
+    
+    rule 'Silver Priority' do |r|
+      r.when do |has|
+        has.customer Customer
+        has.customer.subscription = 'Silver'
+        
+        has.ticket Ticket
+        has.ticket.customer = :customer, :%
+        has.ticket.status = 'New'
+      end
+      
+      r.then = action do |e,vars|
+        vars[:ticket].status = 'Escalate'
+        e.modify vars[:ticket]
+      end
+      #r.duration = 3000
+    end
+    
+    rule 'Gold Priority' do |r|
+      r.when do |has|
+        has.customer Customer
+        has.customer.subscription = 'Gold' 
+        
+        has.ticket Ticket
+        has.ticket.customer = :customer, :%
+        has.ticket.status = 'New' 
+      end
+      
+      r.then = action do |e,vars|
+        vars[:ticket].status = 'Escalate'
+        e.modify vars[:ticket]
+      end
+      #r.duration = 1000
+    end
+    
+    rule 'Platinum Priority' do |r|
+      r.when do |has|
+        has.customer Customer
+        has.customer.subscription = 'Platinum' 
+        
+        has.ticket Ticket
+        has.ticket.customer = :customer, :%
+        has.ticket.status = 'New' 
+      end
+      
+      r.then = action do |e,vars|
+        vars[:ticket].status = 'Escalate'
+        e.modify vars[:ticket]
+      end
+    end
+    
+    rule 'Escalate' do |r|
+      r.when do |has|
+        has.customer Customer
+        
+        has.ticket Ticket
+        has.ticket.customer = :customer, :%
+        has.ticket.status = 'Escalate'
+      end
+      
+      r.then = action do |e,vars|
+        puts 'Email : ' + vars[:ticket].to_s    
+      end
+    end
+    
+    rule 'Done' do |r|
+      r.when do |has|
+        has.customer Customer
+        
+        has.ticket Ticket
+        has.ticket.customer = :customer, :%
+        has.ticket.status = 'Done' 
+      end
+      
+      r.then = action do |e,vars|
+        puts 'Done : ' + vars[:ticket].to_s 
+      end
+    end
+  end
+end
+
+include Ruleby
+
+# 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/fibonacci_example1.rb

@@ -0,0 +1,33 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), '../lib/')
+require 'ruleby'
+require 'fibonacci_rulebook'
+class Fibonacci
+  def initialize(sequence,value=-1)
+    @sequence = sequence
+    @value = value 
+  end
+  
+  attr_reader :sequence  
+  attr :value, true
+  
+  def to_s
+    return '['+super + " sequence=" + @sequence.to_s + ",value=" + @value.to_s + ']'
+  end
+end
+
+include Ruleby
+
+# This example is borrowed from the JBoss-Rule project.
+
+# FACTS
+fib1 = Fibonacci.new(8)
+
+t1 = Time.new
+engine :engine do |e|
+  FibonacciRulebook1.new(e).rules
+  e.assert fib1
+  e.match       
+end
+t2 = Time.new
+diff = t2.to_f - t1.to_f
+puts diff.to_s

data/examples/fibonacci_example2.rb

@@ -0,0 +1,29 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), '../lib/')
+require 'ruleby'
+require 'fibonacci_rulebook'
+class Fibonacci
+  def initialize(sequence,value=-1)
+    @sequence = sequence
+    @value = value 
+  end
+  
+  attr_reader :sequence  
+  attr :value, true
+  
+  def to_s
+    return super + "::sequence=" + @sequence.to_s + ",value=" + @value.to_s
+  end
+end
+
+include Ruleby
+
+# FACTS
+fib1 = Fibonacci.new(1,1)
+fib2 = Fibonacci.new(2,1)
+
+engine :engine do |e|  
+  FibonacciRulebook2.new(e).rules
+  e.assert fib1
+  e.assert fib2
+  e.match       
+end

data/examples/fibonacci_rulebook.rb

@@ -0,0 +1,137 @@
+
+require 'rulebook'
+class FibonacciRulebook2 < Rulebook
+  MAX_SEQUENCE = 100
+  def rules
+    rule 'Calculate' do |r|
+                                
+      r.when do |has|
+        has.f1 Fibonacci
+        has.f1.value.not = -1 
+        has.f1.sequence :s1
+                
+        has.f2 Fibonacci
+        has.f2.value.not = -1 
+        has.f2.sequence :s2
+        has.f2.sequence :s1 do |s, s1| s == (s1 + 1) end
+        
+        has.f3 Fibonacci
+        has.f3.value = -1         
+        has.f3.sequence :s2 do |s, s2| s == (s2 + 1) end
+      end
+    
+      r.then do |e, vars|
+        e.retract vars[:f1]
+        e.retract vars[:f3]
+        if(vars[:f2].sequence == MAX_SEQUENCE)
+          e.retract vars[:f2]
+        else      
+          f3 = Fibonacci.new(vars[:f2].sequence + 1, vars[:f1].value + vars[:f2].value)
+          e.assert f3
+          puts "#{f3.sequence} == #{f3.value}"
+        end
+      end
+      
+      r.priority = 2               
+    end    
+  
+    rule 'Build' do |r|
+      
+      r.when do |has|
+        has.f Fibonacci
+        has.f.value.not = -1 
+        has.f.sequence :s1
+        
+        has.f2 Fibonacci
+        has.f2.value.not = -1 
+        has.f2.sequence :s1 do |s, s1| s == (s1 + 1) end
+      end
+      
+      r.then do |e, vars| 
+        f3 = Fibonacci.new(vars[:f2].sequence + 1, -1)
+        e.assert f3
+      end                                  
+      
+      r.priority = 1
+    end
+  end
+end
+
+class FibonacciRulebook1 < Rulebook
+
+  def rules
+   # Bootstrap1
+   rule  'Bootstrap1' do |r|  
+     r.when do |has|
+         has.f Fibonacci
+         has.f.value = -1 
+         has.f.sequence = 1 
+     end
+     
+     r.then do |e,vars|  
+       vars[:f].value = 1
+       e.modify vars[:f]
+       puts vars[:f].sequence.to_s + ' == ' + vars[:f].value.to_s
+     end     
+   
+     r.priority = 4        
+   end  
+ 
+   # Recurse
+   rule 'Recurse' do |r|  
+     r.when do |has|
+       has.f Fibonacci
+       has.f.value = -1 
+     end
+    
+     r.then do |e,vars|   
+       f2 = Fibonacci.new(vars[:f].sequence - 1)
+       e.assert f2
+       puts 'recurse for ' + f2.sequence.to_s
+     end
+     r.priority = 3
+   end  
+  
+   # Bootstrap2
+   rule 'Bootstrap2' do |r| 
+     r.when do |has|
+        has.f9 Fibonacci
+        has.f9.value = -1 
+        has.f9.sequence = 2
+     end
+     r.then do |e,vars|    
+       vars[:f9].value = 1       
+       e.modify  vars[:f9]
+       puts vars[:f9].sequence.to_s + ' == ' + vars[:f9].value.to_s
+     end
+     r.priority = 0
+   end
+  
+   # Calculate
+   rule 'Calculate' do |r| 
+     r.when do |has|
+       has.f1 Fibonacci
+       has.f1.value.not = -1 
+       has.f1.sequence :s1
+     
+       has.f2 Fibonacci
+       has.f2.value.not = -1        
+       has.f2.sequence :s2
+       has.f2.sequence.references :s1
+       has.f2.sequence do |s2, s1| s2 == (s1 + 1) end
+       
+       has.f3 Fibonacci
+       has.f3.value = -1 
+       has.f3.sequence.references :s2
+       has.f3.sequence do |sequence, s2| sequence == (s2 + 1) end
+    end
+     r.then do |e,vars|
+       vars[:f3].value = vars[:f1].value + vars[:f2].value
+       e.modify vars[:f3]
+       e.retract vars[:f1]
+       puts vars[:f3].sequence.to_s + ' == ' + vars[:f3].value.to_s
+     end
+     r.priority = 0
+   end
+ end
+ end

data/examples/test_self_reference.rb

@@ -0,0 +1,35 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__), '../lib/')
+require 'ruleby'
+require 'rulebook'
+
+class Message
+  def initialize(status,message)
+    @status = status
+    @message = message
+  end
+  attr :status, true
+  attr :message, true
+end
+
+class SelfRefRulebook < Rulebook
+  def rules
+    rule 'HelloWorld' do |r|
+      r.when do |has|
+        has.m2 Message
+        has.m2.message :x
+        has.m2.status = :x, :%
+      end
+      r.then = action do |e,vars|
+        puts 'Success'
+      end
+    end     
+  end
+end
+
+include Ruleby
+
+engine :engine do |e|
+  SelfRefRulebook.new(e).rules
+  e.assert Message.new(:HELLO, :HELLO)
+  e.match     
+end

data/lib/core/atoms.rb

@@ -11,14 +11,11 @@ module Ruleby
       @tag = tag
       @name = name
       @proc = Proc.new(&block) if block_given?
-      @parent = nil # TODO move to AtomNode
     end
     
-    attr :parent, true
     attr_reader :name
     attr_reader :tag
     attr_reader :proc
-
   end
   
   # This kind of atom is used to match just a single, hard coded value.  
@@ -27,28 +24,15 @@ module Ruleby
   #   a.name do |n| n == 'John' end
   # 
   # So there are no references to other atoms.
-  class PropertyAtom < Atom
-    
-    def match?(fact)
-      mr = MatchResult.new
-      temp = fact.object.send("#{@name}")
-      if @proc.call(temp)
-        mr.is_match = true
-        mr.fact_hash[@tag] = fact.id
-        mr.recency.push fact.recency
-        mr[@tag] = temp
-      end
-      return [mr]
-    end
-
-    def matches
-      @parent.obj_results
-    end
-    
+  class PropertyAtom < Atom    
     def ==(atom)      
-      return atom != nil && @tag == atom.tag && @name == atom.name && @proc == atom.proc 
+      return shareable?(atom) && @tag == atom.tag
     end   
     
+    def shareable?(atom)
+      return atom && @name == atom.name && @proc == atom.proc 
+    end
+    
     def to_s
       return 'tag='+@tag.to_s + '[' + matches.join(',') + ']'
     end
@@ -60,17 +44,7 @@ module Ruleby
   # 
   # It is only used at the start of a pattern.
   class TypeAtom < PropertyAtom
-    def match?(fact)
-      mr = MatchResult.new
-      temp = fact.object.send("#{@name}")
-      if @proc.call(temp)
-        mr.is_match = true
-        mr.recency.push fact.recency
-        mr.fact_hash[@tag] = fact.id
-        mr[@tag] = fact.object 
-      end
-      return [mr]
-    end
+
   end
   
   # This kind of atom is used for matching a value that is a variable.
@@ -84,46 +58,9 @@ module Ruleby
     def initialize(tag, name, vars, &block) 
       super(tag, name, &block)
       @vars = vars # list of referenced variable names
-      @var_atoms = Hash.new # will be set when rule is asserted
     end
     
     attr_reader :vars
-    attr :var_atoms, true
-    
-    def match?(fact)
-      local_matches = Array.new      
-      val = fact.object.send("#{@name}")     
-      @vars.each do |v|  
-        # TODO we don't really need to iterate over all the @var_atoms, just
-        # the one that is at the top of the reference chain (i.e. the one that
-        # has references to all of this atoms other references.
-        @var_atoms[v].matches.each do |match| 
-          args = [val]                 
-          args.push match.variables[v]     
-          i = 0; while i < @vars.length
-            if match.key? @vars[i]
-              args.push match.variables[@vars[i]]                
-              i+=1
-            else
-              i = @vars.length + 1
-            end
-          end
-          break if i > @vars.length 
-          if @proc.call(args)   
-            m = MatchResult.new(match.variables.clone, true, match.fact_hash.clone, match.recency)
-            m.recency.push fact.recency
-            m.fact_hash[@tag] = fact.id
-            m.variables[@tag] = val            
-            local_matches.push(m)
-          end
-        end
-      end      
-      return local_matches.uniq
-    end   
-    
-    def matches
-      return @parent.ref_results(@tag)
-    end
     
     def ==(atom)      
       return atom.kind_of?(ReferenceAtom) && @proc == atom.proc && @tag == atom.tag && @vars == atom.vars
@@ -134,6 +71,11 @@ module Ruleby
     end
   end
   
+  # This is an atom that references another atom that is in the same pattern.
+  class SelfReferenceAtom < ReferenceAtom
+    
+  end
+  
   class MatchResult  
   
     # TODO this class needs to be cleaned up for that we don't have a bunch of
@@ -184,7 +126,7 @@ module Ruleby
       @is_match = mr.is_match
       @variables = @variables.update mr.variables      
       
-      # QUESTION why the heck is does this statement work instead of the 
+      # QUESTION why the heck does this statement work instead of the 
       # commented one below it??
       @fact_hash = mr.fact_hash.update @fact_hash
       #@fact_hash = @fact_hash.update mr.fact_hash