ruleby 0.9.b4 → 0.9.b7

data/lib/ruleby.rb

@@ -19,41 +19,4 @@ module Ruleby
     yield e if block_given?
     return e
   end  
-end
-
-class String
-  unless ''.respond_to?(:to_proc)
-    def to_proc &block
-      params = []
-      expr = self
-      sections = expr.split(/\s*->\s*/m)
-      if sections.length > 1 then
-          eval sections.reverse!.inject { |e, p| "(Proc.new { |#{p.split(/\s/).join(', ')}| #{e} })" }, block && block.binding
-      elsif expr.match(/\b_\b/)
-          eval "Proc.new { |_| #{expr} }", block && block.binding
-      else
-          leftSection = expr.match(/^\s*(?:[+*\/%&|\^\.=<>\[]|!=)/m)
-          rightSection = expr.match(/[+\-*\/%&|\^\.=<>!]\s*$/m)
-          if leftSection || rightSection then
-              if (leftSection) then
-                  params.push('$left')
-                  expr = '$left' + expr
-              end
-              if (rightSection) then
-                  params.push('$right')
-                  expr = expr + '$right'
-              end
-          else
-              self.gsub(
-                  /(?:\b[A-Z]|\.[a-zA-Z_$])[a-zA-Z_$\d]*|[a-zA-Z_$][a-zA-Z_$\d]*:|self|arguments|'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"/, ''
-              ).scan(
-                /([a-z_$][a-z_$\d]*)/i
-              ) do |v|  
-                params.push(v) unless params.include?(v)
-              end
-          end
-          eval "Proc.new { |#{params.join(', ')}| #{expr} }", block && block.binding
-      end
-    end
-  end
 end

data/ruleby.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name = %q{ruleby}
+  s.version = "0.9.b7"
+
+  s.authors = [%q{Joe Kutner}, %q{Matt Smith}]
+  s.description = %q{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.
+}
+  s.email = %q{jpkutner@gmail.com}
+  s.homepage = %q{http://ruleby.org}
+  s.files = `git ls-files`.split("\n")
+  s.require_paths = [%q{lib}]
+  s.rubyforge_project = %q{ruleby}
+  s.summary = %q{Rete based Ruby Rule Engine}
+end

data/spec/and_or_spec.rb

@@ -0,0 +1,252 @@
+require 'spec_helper'
+
+class AndOrFact
+  attr :value, true
+  def initialize(v=nil); @value = v; end
+end
+
+class AndOrFact2
+  attr :value, true
+  def initialize(v=nil); @value = v; end
+end
+
+class AndOrFact3
+  attr :value, true
+  def initialize(v=nil); @value = v; end
+end
+
+class AndOrFact4
+  attr :value, true
+  def initialize(v=nil); @value = v; end
+end
+
+class AndOrFact5
+  attr :value, true
+  def initialize(v=nil); @value = v; end
+end
+
+class AndOrFact6
+  attr :value, true
+  def initialize(v=nil); @value = v; end
+end
+
+include Ruleby
+
+class AndOrRulebook < Rulebook
+  def rules
+    rule AND(
+             OR([AndOrFact, m.value > 0]),
+             OR(
+                 OR([AndOrFact, m.value == 1]),
+                 AND(
+                     AND([AndOrFact, m.value < 1]),
+                     OR([AndOrFact, m.value == nil], [:not, AndOrFact])))) do
+      assert Success.new
+    end
+
+#    rule [AndOrFact, m.value > 0],
+#         OR(
+#             [AndOrFact, m.value == 1],
+#             AND(
+#                 [AndOrFact, m.value < 1],
+#                 OR([AndOrFact, m.value == nil], [:not, AndOrFact]))) do
+#      assert Success.new
+#    end
+  end
+
+  def rules2
+    rule OR(AND(OR(OR([AndOrFact, m.value == 1])))) do |v|
+      assert Success.new
+    end
+  end
+
+  def rules3
+    rule OR([AndOrFact, m.value == 1], [AndOrFact, m.value == 2], [AndOrFact, m.value == 3]), [AndOrFact, m.value == 4] do |v|
+      assert Success.new
+    end
+  end
+
+  def rules4
+    rule AND([AndOrFact, :a, m.value == 1], [AndOrFact2, :a2, m.value == 2]) do |v|
+      raise "nil" if v[:a].nil?
+      raise "nil" if v[:a2].nil?
+      assert Success.new
+    end
+  end
+
+  def rules5
+    rule OR(AND([AndOrFact, :a, {m.value == 1 => :x}], [AndOrFact2, m.value == b(:x)])) do |v|
+      assert Success.new
+    end
+  end
+
+  def rules6
+    rule OR(
+           AND([:collect, AndOrFact, m.value == 1]),
+           AND([:collect, AndOrFact2, m.value == 2])
+         ), AND(
+           AND([AndOrFact3, m.value == 65]),
+           OR(
+             OR(
+               OR([AndOrFact4, m.value == 4]),
+               AND([AndOrFact5, m.value == 5])
+             ),
+             OR([AndOrFact6, m.value == 6])
+           )
+         ) do |v|
+      assert Success.new
+    end
+    # all that really matters
+#    rule OR(
+#           [AndOrFact, m.value == 1],
+#           [AndOrFact2, m.value == 2]
+#         ), AND(
+#           [AndOrFact3, m.value == 65],
+#           OR(
+#             [AndOrFact4, m.value == 4],
+#             [AndOrFact5, m.value == 5]
+#           )
+#         ) do |v|
+#      assert Success.new
+#    end
+  end
+end
+
+describe Ruleby::Core::Engine do
+#  describe "AND/OR" do
+    context "crazy AND/OR rules" do
+      subject do
+        engine :engine do |e|
+          AndOrRulebook.new(e).rules
+        end
+      end
+
+      before do
+        subject.assert AndOrFact.new(1)
+        subject.match
+      end
+
+      it "should have matched" do
+        subject.errors.should == []
+        subject.retrieve(Success).size.should == 1
+      end
+    end
+
+    context "nested AND/OR rule" do
+      subject do
+        engine :engine do |e|
+          AndOrRulebook.new(e).rules2
+        end
+      end
+
+      before do
+        subject.assert AndOrFact.new(1)
+        subject.match
+      end
+
+      it "should have matched" do
+        subject.errors.should == []
+        subject.retrieve(Success).size.should == 1
+      end
+    end
+
+    context "multi OR rule" do
+      subject do
+        engine :engine do |e|
+          AndOrRulebook.new(e).rules3
+        end
+      end
+
+      context "with one 1 and one 4" do
+        before do
+          subject.assert AndOrFact.new(1)
+          subject.assert AndOrFact.new(4)
+          subject.match
+        end
+
+        it "should have matched" do
+          subject.errors.should == []
+          subject.retrieve(Success).size.should == 1
+        end
+      end
+    end
+
+    context "nested AND/OR rule" do
+      subject do
+        engine :engine do |e|
+          AndOrRulebook.new(e).rules4
+        end
+      end
+
+      before do
+        subject.assert AndOrFact.new(1)
+        subject.assert AndOrFact2.new(2)
+        subject.match
+      end
+
+      it "should have matched" do
+        subject.errors.should == []
+        subject.retrieve(Success).size.should == 1
+      end
+    end
+
+    context "nested AND/OR rule" do
+      subject do
+        engine :engine do |e|
+          AndOrRulebook.new(e).rules5
+        end
+      end
+
+      before do
+        subject.assert AndOrFact.new(1)
+        subject.assert AndOrFact2.new(1)
+        subject.match
+      end
+
+      it "should have matched" do
+        subject.errors.should == []
+        subject.retrieve(Success).size.should == 1
+      end
+    end
+
+    context "another crazy nested AND/OR rule" do
+      subject do
+        engine :engine do |e|
+          AndOrRulebook.new(e).rules6
+        end
+      end
+
+      before do
+        subject.assert AndOrFact.new(1)
+        subject.assert AndOrFact3.new(3)
+        subject.assert AndOrFact4.new(4)
+        subject.match
+      end
+
+      it "should not have matched" do
+        subject.errors.should == []
+        subject.retrieve(Success).size.should == 0
+      end
+    end
+
+    context "another crazy nested AND/OR rule" do
+      subject do
+        engine :engine do |e|
+          AndOrRulebook.new(e).rules6
+        end
+      end
+
+      before do
+        subject.assert AndOrFact.new(1)
+        subject.assert AndOrFact3.new(65)
+        subject.assert AndOrFact4.new(4)
+        subject.match
+      end
+
+      it "should have matched" do
+        subject.errors.should == []
+        subject.retrieve(Success).size.should == 1
+      end
+    end
+#  end
+end

data/spec/coercion_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Ruleby::Core::Engine do
+
+end

data/spec/collect_spec.rb

@@ -0,0 +1,1021 @@
+require 'spec_helper'
+
+class A
+  attr :value, true
+  def initialize(v=nil); @value = v; end
+end
+
+class B
+  attr :value1, true
+  attr :value2, true
+  def initialize(v1=nil, v2=nil); @value1 = v1; @value2 = v2; end
+end
+
+class C
+
+end
+
+include Ruleby
+
+class CollectRulebook < Rulebook
+  def rules_with_one_pattern
+    rule [:collect, A, :a] do |v|
+      assert v[:a]
+      assert Success.new
+    end
+  end
+
+  def rules_with_one_pattern_and_other_conditions
+    rule [:collect, A, :a, m.value == "foo"] do |v|
+      assert v[:a]
+      assert Success.new
+    end
+
+    rule [:collect, B, :b, m.value1 == "foo", m.value2 == "bar"] do |v|
+      assert v[:b]
+      assert Success.new
+    end
+  end
+
+  def rules_with_one_pattern_inside_and
+    rule AND([:collect, A, :a]) do |v|
+      assert v[:a]
+      assert Success.new
+    end
+  end
+
+  def rules_with_two_collect_patterns_of_same_type
+    rule [:collect, A, :a1], [:collect, A, :a2] do |v|
+      assert v[:a1]
+      assert v[:a2]
+      assert Success.new
+    end
+  end
+
+  def rules_with_two_collect_patterns_of_different_type
+    rule [:collect, A, :a], [:collect, B, :b] do |v|
+      assert v[:a]
+      assert v[:b]
+      assert Success.new
+    end
+  end
+
+  def rules_with_one_pattern_and_a_not_on_right
+    rule [:collect, A, :a], [:not, B] do |v|
+      assert v[:a]
+      assert Success.new
+    end
+  end
+
+  def rules_with_one_pattern_and_a_not_on_left
+    rule [:not, B], [:collect, A, :a] do |v|
+      assert v[:a]
+      assert Success.new
+    end
+  end
+
+  def rules_with_more_than_one_pattern
+    rule [:collect, A, :a], [B, :b] do |v|
+      assert v[:a]
+      assert Success.new(:right)
+    end
+
+    rule [B, :b], [:collect, A, :a] do |v|
+      assert v[:a]
+      assert Success.new(:left)
+    end
+  end
+
+  def rules_with_more_than_one_pattern_on_each_side
+    rule [B, :b], [:collect, A, :a], [C, :c] do |v|
+      assert v[:a]
+      assert Success.new
+    end
+  end
+
+  def rules_with_chaining
+    rule [:collect, A, :a] do |v|
+      assert v[:a]
+      assert Success.new
+    end
+
+    rule [C, :c] do |v|
+      assert A.new
+    end
+  end
+
+  def rules_with_binding
+    rule [:collect, A, :a], [B, :b, m.value1(:a, &c{|v1, a| a.size > 0 and a[0].object.value == v1})] do |v|
+      assert Success.new
+    end
+
+    rule [:collect, A, :a], [B, :b, m.value1(:a, &c{|v1, a| a.size > 1 and a[0].object.value == v1})] do |v|
+      assert Success.new
+    end
+  end
+
+  def rules_with_chaining_and_binding
+    rule [:collect, A, :a], [B, :b, m.value1(:a, &c{|v1, a| a.size > 0})] do |v|
+      assert v[:a]
+      assert Success.new
+    end
+
+    rule [C, :c] do |v|
+      assert A.new
+    end
+  end
+end
+
+describe Ruleby::Core::Engine do
+
+  describe ":collect" do
+
+    shared_examples_for "not patterns with [:collect, A] and [:not, B] when there is a B" do
+      it "should not match" do
+        s = subject.retrieve Success
+        s.should_not be_nil
+        s.size.should == 0
+      end
+
+      it "should match once B is retracted" do
+        a = subject.retrieve B
+        subject.retract a[0]
+
+        subject.match
+
+        s = subject.retrieve Success
+        s.size.should == 1
+        a = subject.retrieve A
+        a.size.should == 2
+      end
+    end
+
+    shared_examples_for "one :collect A rule and one A" do
+      it "should retrieve Success" do
+        s = subject.retrieve Success
+        s.should_not be_nil
+        s.size.should == 1
+
+        s = subject.retrieve Array
+        s.should_not be_nil
+        s.size.should == 1
+
+        a = s[0]
+        a.size.should == 1
+        a[0].object.class.should == A
+      end
+
+      it "should retract without error" do
+        s = subject.retrieve Success
+        s.size.should == 1
+        subject.retract s[0]
+
+        a = subject.retrieve A
+        a.size.should == 1
+        subject.retract a[0]
+
+        subject.match
+
+        s = subject.retrieve Success
+        s.size.should == 0
+        a = subject.retrieve A
+        a.size.should == 0
+      end
+    end
+
+    shared_examples_for "one :collect A rule and two As" do
+      it "should retrieve Success" do
+        s = subject.retrieve Success
+        s.should_not be_nil
+        s.size.should == 1
+
+        s = subject.retrieve Array
+        s.should_not be_nil
+        s.size.should == 1
+
+        a = s[0]
+        a.size.should == 2
+        a[0].object.class.should == A
+        a[1].object.class.should == A
+      end
+
+      it "should retract without error" do
+        s = subject.retrieve Success
+        subject.retract s[0]
+        a = subject.retrieve A
+        subject.retract a[0]
+
+        subject.match
+
+        s = subject.retrieve Success
+        s.size.should == 1
+        a = subject.retrieve A
+        a.size.should == 1
+
+        s = subject.retrieve Success
+        subject.retract s[0]
+        a = subject.retrieve A
+        subject.retract a[0]
+
+        subject.match
+
+        s = subject.retrieve Success
+        s.size.should == 0
+        a = subject.retrieve A
+        a.size.should == 0
+      end
+    end
+
+    context "as one pattern" do
+      subject do
+        engine :engine do |e|
+          CollectRulebook.new(e).rules_with_one_pattern
+        end
+      end
+
+      context "with one A" do
+        before do
+          subject.assert A.new
+          subject.match
+        end
+
+        it_should_behave_like "one :collect A rule and one A"
+      end
+
+      context "with more than one A" do
+        before do
+          subject.assert A.new
+          subject.assert A.new
+          subject.match
+        end
+
+        it_should_behave_like "one :collect A rule and two As"
+      end
+    end
+
+    context "as one pattern and other conditions" do
+      subject do
+        engine :engine do |e|
+          CollectRulebook.new(e).rules_with_one_pattern_and_other_conditions
+        end
+      end
+
+      context "with one A('foo')" do
+        before do
+          subject.assert A.new("foo")
+          subject.match
+        end
+
+        it_should_behave_like "one :collect A rule and one A"
+      end
+
+      context "with more than one A('foo')" do
+        before do
+          subject.assert A.new("foo")
+          subject.assert A.new("foo")
+          subject.match
+        end
+
+        it_should_behave_like "one :collect A rule and two As"
+      end
+
+      context "with one A('foo') and one A(nil)" do
+        before do
+          subject.assert A.new("foo")
+          subject.assert A.new
+          subject.match
+        end
+
+        it "should retrieve Success" do
+          s = subject.retrieve Success
+          s.should_not be_nil
+          s.size.should == 1
+
+          s = subject.retrieve Array
+          s.should_not be_nil
+          s.size.should == 1
+
+          a = s[0]
+          a.size.should == 1
+          a[0].object.class.should == A
+        end
+      end
+
+      context "with more than one A('foo') and one A(nil)" do
+        before do
+          subject.assert A.new("foo")
+          subject.assert A.new("foo")
+          subject.assert A.new
+          subject.match
+        end
+
+        it "should retrieve Success" do
+          s = subject.retrieve Success
+          s.should_not be_nil
+          s.size.should == 1
+
+          s = subject.retrieve Array
+          s.should_not be_nil
+          s.size.should == 1
+
+          a = s[0]
+          a.size.should == 2
+          a[0].object.class.should == A
+          a[1].object.class.should == A
+        end
+      end
+
+      context "with one A(nil)" do
+        before do
+          subject.assert A.new
+          subject.match
+        end
+
+        it "should not succeed" do
+          s = subject.retrieve Success
+          s.should_not be_nil
+          s.size.should == 0
+        end
+      end
+
+      context "with one B(foo,nil)" do
+        before do
+          subject.assert B.new("foo")
+          subject.match
+        end
+
+        it "should not succeed" do
+          s = subject.retrieve Success
+          s.should_not be_nil
+          s.size.should == 0
+        end
+      end
+
+      context "with one B(foo,bar)" do
+        before do
+          subject.assert B.new("foo", "bar")
+          subject.match
+        end
+
+        it "should not succeed" do
+          s = subject.retrieve Success
+          s.should_not be_nil
+          s.size.should == 1
+        end
+      end
+
+      context "with one B(foo,bar) and one B(foo,nil)" do
+        before do
+          subject.assert B.new("foo", "bar")
+          subject.assert B.new("foo", "bar")
+          subject.assert B.new("foo")
+          subject.match
+        end
+
+        it "should succeed" do
+          s = subject.retrieve Success
+          s.should_not be_nil
+          s.size.should == 1
+
+          s = subject.retrieve Array
+          s.should_not be_nil
+          s.size.should == 1
+
+          a = s[0]
+          a.size.should == 2
+          a[0].object.class.should == B
+          a[1].object.class.should == B
+        end
+      end
+    end
+
+    context "as one pattern inside AND" do
+      subject do
+        engine :engine do |e|
+          CollectRulebook.new(e).rules_with_one_pattern_inside_and
+        end
+      end
+
+      context "with one A" do
+        before do
+          subject.assert A.new
+          subject.match
+        end
+
+        it_should_behave_like "one :collect A rule and one A"
+      end
+
+      context "with more than one A" do
+        before do
+          subject.assert A.new
+          subject.assert A.new
+          subject.match
+        end
+
+        it_should_behave_like "one :collect A rule and two As"
+      end
+    end
+
+    context "as two patterns of same type" do
+      subject do
+        engine :engine do |e|
+          CollectRulebook.new(e).rules_with_two_collect_patterns_of_same_type
+        end
+      end
+
+      context "with one A" do
+        before do
+          subject.assert A.new
+          subject.match
+        end
+
+        it "should match" do
+          s = subject.retrieve Success
+          s.should_not be_nil
+          s.size.should == 1
+
+          s = subject.retrieve Array
+          s.should_not be_nil
+          s.size.should == 2
+
+          a = s[0]
+          a.size.should == 1
+          a[0].object.class.should == A
+
+          a = s[1]
+          a.size.should == 1
+          a[0].object.class.should == A
+        end
+      end
+    end
+
+    context "as two patterns of different type" do
+      subject do
+        engine :engine do |e|
+          CollectRulebook.new(e).rules_with_two_collect_patterns_of_different_type
+        end
+      end
+
+      context "with one A" do
+        before do
+          subject.assert A.new
+          subject.match
+        end
+
+        it "should not match" do
+          s = subject.retrieve Success
+          s.should_not be_nil
+          s.size.should == 0
+        end
+      end
+
+      context "with one A and one B" do
+        before do
+          subject.assert A.new
+          subject.assert B.new
+          subject.match
+        end
+
+        it "should not match" do
+          s = subject.retrieve Success
+          s.should_not be_nil
+          s.size.should == 1
+
+          s = subject.retrieve Array
+          s.should_not be_nil
+          s.size.should == 2
+
+          classes = []
+
+          a = s[0]
+          a.size.should == 1
+          classes << a[0].object.class
+
+          a = s[1]
+          a.size.should == 1
+          classes << a[0].object.class
+
+          classes.should include(A, B)
+        end
+      end
+    end
+
+    context "as one pattern and a not on left" do
+      subject do
+        engine :engine do |e|
+          CollectRulebook.new(e).rules_with_one_pattern_and_a_not_on_left
+        end
+      end
+
+      context "with one A" do
+        before do
+          subject.assert A.new
+          subject.match
+        end
+
+        it_should_behave_like "one :collect A rule and one A"
+      end
+
+      context "with more than one A" do
+        before do
+          subject.assert A.new
+          subject.assert A.new
+          subject.match
+        end
+
+        it_should_behave_like "one :collect A rule and two As"
+      end
+
+      context "with more than one A and a B" do
+        before do
+          subject.assert A.new
+          subject.assert A.new
+          subject.assert B.new
+          subject.match
+        end
+
+        it_should_behave_like "not patterns with [:collect, A] and [:not, B] when there is a B"
+      end
+
+      context "with more than one A and a B" do
+        before do
+          subject.assert B.new
+          subject.assert A.new
+          subject.assert A.new
+          subject.match
+        end
+
+        it_should_behave_like "not patterns with [:collect, A] and [:not, B] when there is a B"
+      end
+    end
+
+    context "as one pattern and a not on right" do
+      subject do
+        engine :engine do |e|
+          CollectRulebook.new(e).rules_with_one_pattern_and_a_not_on_right
+        end
+      end
+
+      context "with one A" do
+        before do
+          subject.assert A.new
+          subject.match
+        end
+
+        it_should_behave_like "one :collect A rule and one A"
+      end
+
+      context "with more than one A" do
+        before do
+          subject.assert A.new
+          subject.assert A.new
+          subject.match
+        end
+
+        it_should_behave_like "one :collect A rule and two As"
+      end
+
+      context "with more than one A's first and a B" do
+        before do
+          subject.assert A.new
+          subject.assert A.new
+          subject.assert B.new
+          subject.match
+        end
+
+        it_should_behave_like "not patterns with [:collect, A] and [:not, B] when there is a B"
+      end
+
+      context "with more than one A and a B first" do
+        before do
+          subject.assert B.new
+          subject.assert A.new
+          subject.assert A.new
+          subject.match
+        end
+
+        it_should_behave_like "not patterns with [:collect, A] and [:not, B] when there is a B"
+      end
+    end
+
+    context "as two patterns" do
+      subject do
+        engine :engine do |e|
+          CollectRulebook.new(e).rules_with_more_than_one_pattern
+        end
+      end
+
+      context "with one A" do
+        before do
+          subject.assert A.new
+          subject.assert B.new
+          subject.match
+        end
+
+        it "should retrieve Success" do
+          s = subject.retrieve Success
+          s.should_not be_nil
+          s.size.should == 2
+
+          s = subject.retrieve Array
+          s.should_not be_nil
+          s.size.should == 2
+
+          a = s[0]
+          a.size.should == 1
+          a[0].object.class.should == A
+
+          a = s[1]
+          a.size.should == 1
+          a[0].object.class.should == A
+        end
+      end
+
+      context "with more than one A" do
+        before do
+          subject.assert A.new
+          subject.assert B.new
+          subject.assert A.new
+          subject.match
+        end
+
+        it "should retrieve Success" do
+          s = subject.retrieve Success
+          s.should_not be_nil
+          s.size.should == 2
+
+          s = subject.retrieve Array
+          s.should_not be_nil
+          s.size.should == 2 # one array for each rule
+
+          a = s[0]
+          a.size.should == 2
+          a[0].object.class.should == A
+          a[1].object.class.should == A
+
+          a = s[1]
+          a.size.should == 2
+          a[0].object.class.should == A
+          a[1].object.class.should == A
+        end
+
+        it "should retract A without error" do
+          s = subject.retrieve Success
+          subject.retract s[0]
+          subject.retract s[1]
+          a = subject.retrieve A
+          subject.retract a[0]
+
+          subject.match
+
+          s = subject.retrieve Success
+          s.size.should == 2
+          a = subject.retrieve A
+          a.size.should == 1
+
+          s = subject.retrieve Success
+          subject.retract s[0]
+          subject.retract s[1]
+          a = subject.retrieve A
+          subject.retract a[0]
+
+          subject.match
+
+          s = subject.retrieve Success
+          s.size.should == 0
+          a = subject.retrieve A
+          a.size.should == 0
+        end
+
+        it "should retract B without error" do
+          s = subject.retrieve Success
+          subject.retract s[0]
+          subject.retract s[1]
+          b = subject.retrieve B
+          subject.retract b[0]
+
+          subject.match
+
+          s = subject.retrieve Success
+          s.size.should == 0
+          a = subject.retrieve A
+          a.size.should == 2
+          b = subject.retrieve B
+          b.size.should == 0
+        end
+      end
+    end
+
+    context "as patterns on each side" do
+      subject do
+        engine :engine do |e|
+          CollectRulebook.new(e).rules_with_more_than_one_pattern_on_each_side
+        end
+      end
+
+      context "with one A" do
+        context "and no C" do
+          before do
+            subject.assert A.new
+            subject.assert B.new
+            subject.match
+          end
+
+          it "should retrieve Success" do
+            s = subject.retrieve Success
+            s.should_not be_nil
+            s.size.should == 0
+          end
+        end
+
+        context "and all other facts" do
+          before do
+            subject.assert A.new
+            subject.assert B.new
+            subject.assert C.new
+            subject.match
+          end
+
+          it "should retrieve Success" do
+            s = subject.retrieve Success
+            s.should_not be_nil
+            s.size.should == 1
+
+            s = subject.retrieve Array
+            s.should_not be_nil
+            s.size.should == 1
+
+            a = s[0]
+            a.size.should == 1
+            a[0].object.class.should == A
+          end
+        end
+      end
+
+      context "with more than one A" do
+        before do
+          subject.assert A.new
+          subject.assert B.new
+          subject.assert C.new
+          subject.assert A.new
+          subject.match
+        end
+
+        it "should retrieve Success" do
+          s = subject.retrieve Success
+          s.should_not be_nil
+          s.size.should == 1
+
+          s = subject.retrieve Array
+          s.should_not be_nil
+          s.size.should == 1
+
+          a = s[0]
+          a.size.should == 2
+          a[0].object.class.should == A
+          a[1].object.class.should == A
+        end
+
+        it "should retract A without error" do
+          s = subject.retrieve Success
+          subject.retract s[0]
+          a = subject.retrieve A
+          subject.retract a[0]
+
+          subject.match
+
+          s = subject.retrieve Success
+          s.size.should == 1
+          a = subject.retrieve A
+          a.size.should == 1
+
+          s = subject.retrieve Success
+          subject.retract s[0]
+          a = subject.retrieve A
+          subject.retract a[0]
+
+          subject.match
+
+          s = subject.retrieve Success
+          s.size.should == 0
+          a = subject.retrieve A
+          a.size.should == 0
+        end
+
+        it "should retract B without error" do
+          s = subject.retrieve Success
+          subject.retract s[0]
+          b = subject.retrieve B
+          subject.retract b[0]
+
+          subject.match
+
+          s = subject.retrieve Success
+          s.size.should == 0
+          a = subject.retrieve A
+          a.size.should == 2
+          b = subject.retrieve B
+          b.size.should == 0
+        end
+
+        it "should retract C without error" do
+          s = subject.retrieve Success
+          subject.retract s[0]
+          b = subject.retrieve C
+          subject.retract b[0]
+
+          subject.match
+
+          s = subject.retrieve Success
+          s.size.should == 0
+          a = subject.retrieve A
+          a.size.should == 2
+          b = subject.retrieve C
+          b.size.should == 0
+        end
+      end
+    end
+
+    context "as rule chain" do
+      subject do
+        engine :engine do |e|
+          CollectRulebook.new(e).rules_with_chaining
+        end
+      end
+
+      context "with one C" do
+        before do
+          subject.assert C.new
+          subject.match
+        end
+
+        it "should retrieve Success" do
+          s = subject.retrieve Success
+          s.should_not be_nil
+          s.size.should == 1
+
+          s = subject.retrieve Array
+          s.should_not be_nil
+          s.size.should == 1
+
+          a = s[0]
+          a.size.should == 1
+          a[0].object.class.should == A
+        end
+      end
+
+      context "with many C's" do
+        before do
+          subject.assert C.new
+          subject.assert C.new
+          subject.assert C.new
+          subject.assert C.new
+          subject.assert C.new
+          subject.match
+        end
+
+        it "should retrieve Success" do
+          s = subject.retrieve Success
+          s.should_not be_nil
+          s.size.should == 1
+
+          s = subject.retrieve Array
+          s.should_not be_nil
+          s.size.should == 1
+
+          a = s[0]
+          a.size.should == 5
+          a[0].object.class.should == A
+        end
+      end
+    end
+
+    context "with rule binding" do
+      subject do
+        engine :engine do |e|
+          CollectRulebook.new(e).rules_with_binding
+        end
+      end
+
+      context "with one A and one B that have == values" do
+        before do
+          a = A.new
+          a.value = 1
+          b = B.new
+          b.value1 = 1
+          subject.assert b
+          subject.assert a
+          subject.match
+        end
+
+        it "should retrieve Success" do
+          s = subject.retrieve Success
+          s.size.should == 1
+        end
+      end
+
+      context "with one A and one B that have == values asserted in reverse order" do
+        before do
+          a = A.new
+          a.value = 1
+          b = B.new
+          b.value1 = 1
+          subject.assert a
+          subject.assert b
+          subject.match
+        end
+
+        it "should retrieve Success" do
+          s = subject.retrieve Success
+          s.size.should == 1
+        end
+      end
+
+      context "with one A and one B that have != values" do
+        before do
+          a = A.new
+          a.value = 1
+          b = B.new
+          b.value1 = 42
+          subject.assert a
+          subject.assert b
+          subject.match
+        end
+
+        it "should retrieve Success" do
+          s = subject.retrieve Success
+          s.size.should == 0
+        end
+      end
+
+      context "with one A and one B that have != values" do
+        before do
+          a1 = A.new
+          a1.value = 1
+          b1 = B.new
+          b1.value1 = 1
+          a2 = A.new
+          a2.value = 1
+          subject.assert a1
+          subject.assert b1
+          subject.assert a2
+          subject.match
+        end
+
+        it "should retrieve Success" do
+          s = subject.retrieve Success
+          s.size.should == 2
+        end
+      end
+    end
+
+
+    context "as rule chain with binding" do
+      subject do
+        engine :engine do |e|
+          CollectRulebook.new(e).rules_with_chaining_and_binding
+        end
+      end
+
+      context "with one B and one C" do
+        before do
+          subject.assert B.new
+          subject.assert C.new
+          subject.match
+        end
+
+        it "should retrieve Success" do
+          subject.retrieve(Success).size.should == 1
+        end
+      end
+
+      context "with many C's and two B" do
+        before do
+          subject.assert C.new
+          subject.assert C.new
+          subject.assert B.new
+          subject.assert C.new
+          subject.assert C.new
+          subject.assert C.new
+          subject.assert B.new
+          subject.match
+        end
+
+        it "should retrieve Success" do
+          subject.retrieve(Success).size.should == 2
+
+          s = subject.retrieve Array
+          s.size.should == 2
+
+          a = s[0]
+          a.size.should == 5
+          a.each {|o| o.object.class.should == A }
+
+          a = s[1]
+          a.size.should == 5
+          a.each {|o| o.object.class.should == A }
+        end
+      end
+    end
+  end
+end