ruleby 0.9.b4 → 0.9.b7

data/spec/errors_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+class A
+  attr :value, true
+  def initialize(v=nil); @value = v; end
+end
+
+include Ruleby
+
+class ErrorsRulebook < Rulebook
+  def rules_with_method_that_doesnt_exist
+    rule [A, :a, m.foobar == 'quack'] do |v|
+      assert Success.new
+    end
+  end
+
+  def rules_that_raise_errors
+    rule [A, :a, m.value(&c{|v| raise ":(" if v == 42; true})] do |v|
+      assert Success.new
+    end
+  end
+
+end
+
+describe Ruleby::Core::Engine do
+
+  describe "#errors" do
+    context "rules_with_method_that_doesnt_exist" do
+      subject do
+        engine :engine do |e|
+          ErrorsRulebook.new(e).rules_with_method_that_doesnt_exist
+        end
+      end
+
+      context "with one A" do
+        before do
+          subject.assert A.new
+          subject.match
+        end
+
+        it "should accumulate an error" do
+          r = subject.retrieve Success
+          r.size.should == 0
+
+          errors = subject.errors
+          errors.should_not be_nil
+          errors.size.should == 1
+          errors[0].type.should == :no_method
+          errors[0].details[:method].should == :foobar
+          errors[0].details[:object].should match /#<A:(.+)>/
+          subject.clear_errors
+
+          subject.errors.should == []
+        end
+      end
+
+      context "with one A that quacks" do
+        before do
+          a = A.new
+
+          # define a method on the instance (not on the class)
+          def a.foobar
+            "quack"
+          end
+
+          subject.assert a
+          subject.assert A.new
+          subject.match
+        end
+
+        it "should accumulate one error" do
+          r = subject.retrieve Success
+          r.size.should == 1
+
+          errors = subject.errors
+          errors.should_not be_nil
+          errors.size.should == 1
+          errors[0].type.should == :no_method
+          errors[0].details[:method].should == :foobar
+          errors[0].details[:object].should match /#<A:(.+)>/
+          subject.clear_errors
+        end
+      end
+    end
+
+
+    context "rules_that_raise_errors" do
+      subject do
+        engine :engine do |e|
+          ErrorsRulebook.new(e).rules_that_raise_errors
+        end
+      end
+
+      context "with one A where value==42" do
+        before do
+          a = A.new
+          a.value = 42
+          subject.assert a
+          subject.match
+        end
+
+        it "should accumulate an error" do
+          r = subject.retrieve Success
+          r.size.should == 0
+
+          errors = subject.errors
+          errors.should_not be_nil
+          errors.size.should == 1
+          errors[0].type.should == :proc_call
+          errors[0].details[:message].should == ':('
+          errors[0].details[:object].should match /#<A:(.+)>/
+          errors[0].details[:method].should == :value
+          errors[0].details[:value].should == "42"
+          subject.clear_errors
+        end
+      end
+
+      context "with one A where value==42, and one A where value==0" do
+        before do
+          a1 = A.new
+          a1.value = 42
+
+          a2 = A.new
+          a2.value = 0
+
+          subject.assert a1
+          subject.assert a2
+          subject.match
+        end
+
+        it "should accumulate one error" do
+          r = subject.retrieve Success
+          r.size.should == 1
+
+          errors = subject.errors
+          errors.should_not be_nil
+          errors.size.should == 1
+          errors[0].type.should == :proc_call
+          errors[0].details[:message].should == ':('
+          errors[0].details[:object].should match /#<A:(.+)>/
+          errors[0].details[:method].should == :value
+          errors[0].details[:value].should == "42"
+          subject.clear_errors
+        end
+      end
+    end
+  end
+end

data/spec/ferrari_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+class A
+
+end
+
+include Ruleby
+
+class FerrariRulebook < Rulebook
+  def rules
+    rule [A] do |v|
+      assert Success.new
+    end
+  end
+end
+
+describe Ruleby::Core::Engine do
+
+  subject do
+    engine :engine do |e|
+      FerrariRulebook.new(e).rules
+    end
+  end
+
+  describe "simple case" do
+    context "with one A" do
+      before do
+        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
+      end
+    end
+  end
+end

data/spec/function_spec.rb

@@ -0,0 +1,199 @@
+require 'spec_helper'
+
+class FuncFact
+  attr :value, true
+  attr :times, true
+  def initialize(v=nil); @value = v; @times = 0; end
+end
+
+include Ruleby
+
+class FunctionsRulebook < Rulebook
+  def rules_with_simple_function
+    rule [FuncFact, :a, f("b", c{|a, b| b == "b"})] do |v|
+      assert Success.new
+    end
+  end
+
+  def rules_with_function_testing_self(arg)
+    rule [FuncFact, :a, f(arg, c{|a, b| a.value == b})] do |v|
+      assert Success.new
+    end
+  end
+
+  def rules_that_share_a_function
+    func = c{|a, b| a.times += 1; b == "foobar"}
+
+    rule [FuncFact, :a, m.value > 1, f("foobar", func)] do |v|
+      assert Success.new
+    end
+
+    rule [FuncFact, :a, m.value > 2, f("foobar", func)] do |v|
+      assert Success.new
+    end
+  end
+
+  def rules_with_many_args_function
+    rule [FuncFact, :a, f([1, 2, 3, 4], c{|a, b, c, d, e| b < e})] do |v|
+      assert Success.new
+    end
+  end
+
+  def rules_with_no_args_function
+    rule [FuncFact, :a, f(c{|a| !a.nil?})] do |v|
+      assert Success.new
+    end
+  end
+end
+
+describe Ruleby::Rulebook do
+
+  describe "#f" do
+    context "rules_with_simple_function" do
+      subject do
+        engine :engine do |e|
+          FunctionsRulebook.new(e).rules_with_simple_function
+        end
+      end
+
+      context "with one FuncFact" do
+        before do
+          subject.assert FuncFact.new
+          subject.match
+        end
+
+        it "should match once" do
+          r = subject.retrieve Success
+          r.size.should == 1
+          subject.errors.should == []
+        end
+      end
+    end
+
+    context "rules_with_function_testing_self(:foo)" do
+      subject do
+        engine :engine do |e|
+          FunctionsRulebook.new(e).rules_with_function_testing_self(:foo)
+        end
+      end
+
+      context "with one FuncFact" do
+        before do
+          subject.assert FuncFact.new(:foo)
+          subject.match
+        end
+
+        it "should match once" do
+          r = subject.retrieve Success
+          r.size.should == 1
+          subject.errors.should == []
+        end
+      end
+    end
+
+    context "rules_with_function_testing_self(:bar)" do
+      subject do
+        engine :engine do |e|
+          FunctionsRulebook.new(e).rules_with_function_testing_self(:bar)
+        end
+      end
+
+      context "with one FuncFact" do
+        before do
+          subject.assert FuncFact.new(:foo)
+          subject.match
+        end
+
+        it "should not match " do
+          r = subject.retrieve Success
+          r.size.should == 0
+          subject.errors.should == []
+        end
+      end
+    end
+
+    context "rules_that_share_a_function" do
+      subject do
+        engine :engine do |e|
+          FunctionsRulebook.new(e).rules_that_share_a_function
+        end
+      end
+
+      context "with one FuncFact" do
+        before do
+          @f = FuncFact.new(3)
+          subject.assert @f
+          subject.match
+        end
+
+        it "should match, node should be shared, function should be evaled once" do
+          r = subject.retrieve Success
+          r.size.should == 2
+          subject.errors.should == []
+
+          @f.times.should == 1
+
+          subject.retract r[0]
+          subject.retract r[1]
+          subject.retract @f
+          subject.match
+
+          r = subject.retrieve Success
+          r.size.should == 0
+          subject.errors.should == []
+
+          subject.assert @f
+          subject.match
+
+          r = subject.retrieve Success
+          r.size.should == 2
+          subject.errors.should == []
+
+          @f.times.should == 2
+        end
+      end
+    end
+
+    context "rules_with_many_args_function" do
+      subject do
+        engine :engine do |e|
+          FunctionsRulebook.new(e).rules_with_many_args_function
+        end
+      end
+
+      context "with one FuncFact" do
+        before do
+          subject.assert FuncFact.new
+          subject.match
+        end
+
+        it "should match once" do
+          r = subject.retrieve Success
+          r.size.should == 1
+          subject.errors.should == []
+        end
+      end
+    end
+
+    context "rules_with_no_args_function" do
+      subject do
+        engine :engine do |e|
+          FunctionsRulebook.new(e).rules_with_no_args_function
+        end
+      end
+
+      context "with one FuncFact" do
+        before do
+          subject.assert FuncFact.new
+          subject.match
+        end
+
+        it "should match once" do
+          r = subject.retrieve Success
+          r.size.should == 1
+          subject.errors.should == []
+        end
+      end
+    end
+  end
+end

data/spec/hello_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+class HelloFact
+  attr :value, true
+  def initialize(v=nil); @value = v; end
+end
+
+include Ruleby
+
+class HelloRulebook < Rulebook
+  def rules
+    rule [HelloFact, :h] do
+      assert Success.new
+    end
+  end
+end
+
+describe Ruleby::Core::Engine do
+  subject do
+    engine :engine do |e|
+      HelloRulebook.new(e).rules
+    end
+  end
+
+  before do
+    subject.assert HelloFact.new
+    subject.match
+  end
+
+  it "should have matched" do
+    subject.errors.should == []
+    subject.retrieve(Success).size.should == 1
+  end
+end

data/spec/node_sharing_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+class NodeShareFact
+  attr_reader :times
+
+  def initialize(v=nil); @value = v; @times = 0; end
+
+  def value
+    @times += 1
+    @value
+  end
+end
+
+include Ruleby
+
+class NodeShareRulebook < Rulebook
+  def rules
+    rule [NodeShareFact, :n, m.value == 5] do
+      assert Success.new
+    end
+
+    rule [NodeShareFact, :n, m.value == 5] do
+      assert Success.new
+    end
+
+    rule [NodeShareFact, :n, m.value == 6] do
+      assert Success.new
+    end
+  end
+end
+
+describe Ruleby::Core::Engine do
+
+  describe "node sharing" do
+    subject do
+      engine :engine do |e|
+        NodeShareRulebook.new(e).rules
+      end
+    end
+
+    before do
+      @f = NodeShareFact.new(5)
+      subject.assert @f
+      subject.match
+    end
+
+    it "should have matched" do
+      @f.times.should == 1
+      subject.errors.should == []
+      subject.retrieve(Success).size.should == 2
+    end
+  end
+end