rubylog 2.0.1 → 2.1.0

data/spec/integration/dsl_spec.rb

@@ -1,38 +1,41 @@
 require "spec_helper" 
 
-describe "Rubylog dsl", :rubylog=>true do
-
-  describe "prefix functors" do
-    before do
-      predicate_for singleton_class, ".we_have()"
-      we_have! :weapons
-      we_have! :sunglasses
-      we_have! :rustling_leather_coats
-    end
+module RubylogSpec
 
-    it "works" do
-      check we_have :sunglasses
-    end
-    
-    it "works with qmarks" do
-      check { we_have? :rustling_leather_coats }
+  describe "Rubylog dsl", :rubylog=>true do
+
+    describe "prefix functors" do
+      before do
+        predicate_for singleton_class, ".we_have()"
+        we_have! :weapons
+        we_have! :sunglasses
+        we_have! :rustling_leather_coats
+      end
+
+      it "works" do
+        check we_have :sunglasses
+      end
+      
+      it "works with qmarks" do
+        check { we_have? :rustling_leather_coats }
+      end
     end
-  end
 
 
-  describe "built-in prefix functors" do
-    check all X.is(4).and(Y.is(X)), Y.is(4)
-    check any X.is(4)
-    check one(X.in([1,2,3])) { X % 2  == 0 }
-    check none X.in([1,2,3]), X.is(5)
-    check { all?(X.is(4)) { X < 5 } }
-  end
+    describe "built-in prefix functors" do
+      check all X.is(4).and(Y.is(X)), Y.is(4)
+      check any X.is(4)
+      check one(X.in([1,2,3])) { X % 2  == 0 }
+      check none X.in([1,2,3]), X.is(5)
+      check { all?(X.is(4)) { X < 5 } }
+    end
 
-  describe "variables" do
-    check A.is(ANY).and{ A == Rubylog::Variable.new(:ANY) }
-    check A.is(4)  .and{ A == 4 }
-    check B.is(A)  .and{ A == Rubylog::Variable.new(:A) and B == Rubylog::Variable.new(:A) }
-    check B.is(ANY).and{ A == Rubylog::Variable.new(:A) }
-  end
+    describe "variables" do
+      check A.is(ANY).and{ A == Rubylog::Variable.new(:ANY) }
+      check A.is(4)  .and{ A == 4 }
+      check B.is(A)  .and{ A == Rubylog::Variable.new(:A) and B == Rubylog::Variable.new(:A) }
+      check B.is(ANY).and{ A == Rubylog::Variable.new(:A) }
+    end
 
+  end
 end

data/spec/rspec/rubylog_spec.rb

@@ -1,75 +1,69 @@
 require "spec_helper"
 
-describe "Rubylog", :rubylog => true do
+module RubylogSpec
+  describe "Rubylog", :rubylog => true do
 
-  predicate_for Integer, ".even"
+    predicate_for Integer, ".even"
 
-  N.even.if { N%2 == 0 }
+    N.even.if { N%2 == 0 }
 
-  it "checks for true statements" do
-    check :true
-  end
+    it "checks for true statements" do
+      check :true
+    end
 
-  it "raises an exception for false statements" do
-    proc{check :fail}.should raise_exception(Rubylog::CheckFailed)
+    it "raises an exception for false statements" do
+      proc{check :fail}.should raise_exception(Rubylog::CheckFailed)
 
-    self.default_subject = Integer
-    proc{check 4.is 5}.should raise_exception(Rubylog::CheckFailed)
-  end
+      self.default_subject = Integer
+      proc{check 4.is 5}.should raise_exception(Rubylog::CheckFailed)
+    end
 
-  it "can use variables" do
-    check A.is 3
-  end
+    it "can use predicates" do
+      check((A.in [1,2]).and(B.in([2,3])).and(A.is 1).and(B.is 3))
+    end
 
-  it "can use predicates" do
-    check((A.in [1,2]).and(B.in([2,3])).and(A.is 1).and(B.is 3))
-  end
+    it "can assert predicates" do
+      predicate_for Integer, ".divides()"
+      (A.divides B).if {B%A == 0}
+      check(4.divides 12)
+      check((4.divides 30).false)
+    end
 
-  it "can assert predicates" do
-    predicate_for Integer, ".divides()"
-    (A.divides B).if {B%A == 0}
-    check(4.divides 12)
-    check((4.divides 30).false)
-  end
+    it "can use predicates defined outside" do
+      check 1.even.false
+      check 2.even
+    end
 
-  it "can use predicates defined outside" do
-    check 1.even.false
-    check 2.even
-  end
+    describe "nested check" do
+      it "works" do
+        check 9.even.false
+      end
+    end
 
-  describe "nested check" do
-    it "works" do
-      check 9.even.false
+    # inline check
+    check 0.even
+    
+    describe "nested inline check" do
+      check 3.even.false
+      check 4.even
     end
-  end
 
-  # inline check
-  check 0.even
-  
-  describe "nested inline check" do
-    check 3.even.false
-    check 4.even
   end
 
-end
+  describe "Rubylog" do
+    describe "when not included" do
 
-describe "Rubylog" do
-  describe "when not included" do
+      it "does not add methods" do
+        proc{check :true}.should raise_exception NameError
+        proc{trace}.should raise_exception NameError
+      end
 
-    it "does not add methods" do
-      proc{check :true}.should raise_exception NameError
-      proc{trace}.should raise_exception NameError
     end
-
-    it "does not add constants" do
-      proc{A}.should raise_exception NameError
-    end
-
   end
-end
 
+end
 
 
-#require "rspec/core/formatters/progress_formatter"
-#require "rspec/core/formatters/documentation_formatter"
-#EG.run RSpec::Core::Reporter.new RSpec::Core::Formatters::DocumentationFormatter.new(STDOUT) 
+  #require "rspec/core/formatters/progress_formatter"
+  #require "rspec/core/formatters/documentation_formatter"
+  #EG.run RSpec::Core::Reporter.new RSpec::Core::Formatters::DocumentationFormatter.new(STDOUT) 

data/spec/rubylog/assertable_spec.rb

@@ -1,111 +1,113 @@
 require "spec_helper"
 
-describe "rules", :rubylog=>true do
-  before do
-    predicate_for Symbol, ".likes(Drink) .is_happy .has()"
-    predicate_for_context ".we_have()"
-  end
-
-  describe "with prolog body" do
-    it "cannot be asserted in a builtin's desc" do
-      lambda {
-        :john.likes(:beer).and! :jane.likes(:milk)
-      }.should raise_error
+module RubylogSpec
+  describe "rules", :rubylog=>true do
+    before do
+      predicate_for Symbol, ".likes(Drink) .is_happy .has()"
+      predicate_for_context ".we_have()"
     end
 
-    it "can be asserted with if" do
-      :john.is_happy.if we_have(:beer)
-      :john.is_happy?.should be_false
-      we_have!(:beer)
-      :john.is_happy?.should be_true
-    end
+    describe "with prolog body" do
+      it "cannot be asserted in a builtin's desc" do
+        lambda {
+          :john.likes(:beer).and! :jane.likes(:milk)
+        }.should raise_error
+      end
 
-    it "can be asserted with unless" do
-      :john.is_happy.unless we_have(:problem)
-      :john.is_happy?.should be_true
-      we_have!(:problem)
-      :john.is_happy?.should be_false
-    end
+      it "can be asserted with if" do
+        :john.is_happy.if we_have(:beer)
+        :john.is_happy?.should be_false
+        we_have!(:beer)
+        :john.is_happy?.should be_true
+      end
 
-    it "can do simple general implications" do
-      X.is_happy.if X.likes(Y).and X.has(Y)
-      :john.likes! :milk
-      :john.is_happy?.should be_false
-      :john.has! :beer
-      :john.is_happy?.should be_false
-      :john.likes! :beer
-      :john.is_happy?.should be_true
-    end
+      it "can be asserted with unless" do
+        :john.is_happy.unless we_have(:problem)
+        :john.is_happy?.should be_true
+        we_have!(:problem)
+        :john.is_happy?.should be_false
+      end
 
-    it "can yield implied solutions" do
-      predicate_for Symbol, ".brother() .father() .uncle()"
-      X.brother(Y).if X.father(Z).and Y.father(Z).and {X != Y}
-      X.uncle(Y).if X.father(Z).and Z.brother(Y)
+      it "can do simple general implications" do
+        X.is_happy.if X.likes(Y).and X.has(Y)
+        :john.likes! :milk
+        :john.is_happy?.should be_false
+        :john.has! :beer
+        :john.is_happy?.should be_false
+        :john.likes! :beer
+        :john.is_happy?.should be_true
+      end
 
-      :john.father! :dad
-      :jack.father! :dad
-      :dad.father! :grandpa
-      :jim.father! :grandpa
+      it "can yield implied solutions" do
+        predicate_for Symbol, ".brother() .father() .uncle()"
+        X.brother(Y).if X.father(Z).and Y.father(Z).and {X != Y}
+        X.uncle(Y).if X.father(Z).and Z.brother(Y)
 
-      (:john.brother X).map{X}.should == [:jack]
-      (:john.father X).map{X}.should == [:dad]
-      (X.father :dad).map{X}.should == [:john, :jack]
-      (ANY.father X).map{X}.should == [:dad, :dad, :grandpa, :grandpa]
-      (:john.uncle X).map{X}.should == [:jim]
-    end
-  end
+        :john.father! :dad
+        :jack.father! :dad
+        :dad.father! :grandpa
+        :jim.father! :grandpa
 
-  describe "with ruby body" do
-    it "can be asserted (true)" do
-      :john.is_happy.if proc{ true }
-      :john.is_happy?.should be_true
+        (:john.brother X).map{X}.should == [:jack]
+        (:john.father X).map{X}.should == [:dad]
+        (X.father :dad).map{X}.should == [:john, :jack]
+        (ANY.father X).map{X}.should == [:dad, :dad, :grandpa, :grandpa]
+        (:john.uncle X).map{X}.should == [:jim]
+      end
     end
 
-    it "can be asserted (false)" do
-      :john.is_happy.if proc{ false }
-      :john.is_happy?.should be_false
-    end
+    describe "with ruby body" do
+      it "can be asserted (true)" do
+        :john.is_happy.if proc{ true }
+        :john.is_happy?.should be_true
+      end
 
-    it "can be asserted implicitly (true)" do
-      :john.is_happy.if { true }
-      :john.is_happy?.should be_true
-    end
+      it "can be asserted (false)" do
+        :john.is_happy.if proc{ false }
+        :john.is_happy?.should be_false
+      end
 
-    it "can be asserted implicitly (false)" do
-      :john.is_happy.if { false }
-      :john.is_happy?.should be_false
-    end
+      it "can be asserted implicitly (true)" do
+        :john.is_happy.if { true }
+        :john.is_happy?.should be_true
+      end
 
-    it "run the body during every query" do
-      count = 0
-      :john.is_happy.if proc{ count += 1 }
-      count.should == 0
-      :john.is_happy?
-      count.should == 1
-      :john.is_happy?
-      count.should == 2
-    end
+      it "can be asserted implicitly (false)" do
+        :john.is_happy.if { false }
+        :john.is_happy?.should be_false
+      end
+
+      it "run the body during every query" do
+        count = 0
+        :john.is_happy.if proc{ count += 1 }
+        count.should == 0
+        :john.is_happy?
+        count.should == 1
+        :john.is_happy?
+        count.should == 2
+      end
 
-    it "can take arguments" do
-      predicate_for Integer, ".divides()"
-      (A.divides B).if proc{B % A == 0}
-      (4.divides? 16).should be_true
-      (4.divides? 17).should be_false
-      (4.divides? 18).should be_false
-      (3.divides? 3).should be_true
-      (3.divides? 4).should be_false
-      (3.divides? 5).should be_false
-      (3.divides? 6).should be_true
+      it "can take arguments" do
+        predicate_for Integer, ".divides()"
+        (A.divides B).if proc{B % A == 0}
+        (4.divides? 16).should be_true
+        (4.divides? 17).should be_false
+        (4.divides? 18).should be_false
+        (3.divides? 3).should be_true
+        (3.divides? 4).should be_false
+        (3.divides? 5).should be_false
+        (3.divides? 6).should be_true
+      end
     end
-  end
 
-  describe "#if!" do
-    it "can be used to cut off branches" do
-      predicate_for Integer, ".divides()"
-      1.divides(X).if! :true
-      (A.divides B).if proc{B % A == 0}
-      1.divides(4).map{}.should == [nil]
-      2.divides(4).map{}.should == [nil]
+    describe "#if!" do
+      it "can be used to cut off branches" do
+        predicate_for Integer, ".divides()"
+        1.divides(X).if! :true
+        (A.divides B).if proc{B % A == 0}
+        1.divides(4).map{}.should == [nil]
+        2.divides(4).map{}.should == [nil]
+      end
     end
   end
 end

data/spec/rubylog/builtins/arithmetics_spec.rb

@@ -1,94 +1,96 @@
 require "spec_helper"
 
-describe "Arithmetics builtins", :rubylog=>true do
-  check 5.sum_of 2, 3
-
-  check((5.sum_of 2, 6).false)
-
-  check { 5.sum_of(3, A).map{A}.eql? [2] }
-  check { 5.sum_of(A, 2).map{A}.eql? [3] }
-  check { A.sum_of(3, 4).map{A}.eql? [7] }
-
-  check A.is(5).and B.is(3).and C.is(2).and A.sum_of(C, B)
-
-  it "works with functions" do
-    check A.is(5).and 5.sum_of(proc{2}, proc{A-2})
-    check A.is(5).and 5.sum_of(proc{3}, proc{A-2}).false
-  end
-
-  it "checks types" do
-    check 4.sum_of(2,2.0).false
-    check 4.0.sum_of(2.0,2.0)
-  end
-
-  it "can add strings" do
-    A.sum_of(B,C).predicate.add_functor_to String
-    check "hello".sum_of("he", "llo")
-  end
-
-  it "can add arrays" do
-    A.sum_of(B,C).predicate.add_functor_to Array
-    check [1,2,3].sum_of([1,2], [3])
-  end
-
-  it "can subtract arrays" do
-    A.sum_of(B,C).predicate.add_functor_to Array
-    [1,2,3].sum_of(X, [3]).map{X}.should be_eql [[1,2]]
-  end
-
-  it "can multiply integers" do
-    A.product_of(3,2).map{A}.should be_eql [6]
-  end
-
-  it "can divide integers" do
-    6.product_of(A,2).map{A}.should be_eql [3]
-  end
-
-  it "can divide integers" do
-    6.product_of(3,A).map{A}.should be_eql [2]
-  end
-
-  it "can divide floats" do
-    6.0.product_of(A,2.0).map{A}.should be_eql [3.0]
-  end
-
-  it "can divide floats" do
-    6.0.product_of(3.0,A).map{A}.should be_eql [2.0]
-  end
-
-  it "checks non-divisibility of integers" do
-    6.product_of(5,A).map{A}.should be_eql []
-  end
-
-  it "checks non-divisibility of integers" do
-    6.product_of(A,4).map{A}.should be_eql []
-  end
-
-  it "casts types" do
-    6.0.product_of(A,2).map{A}.should be_eql [3.0]
-  end
-
-  it "casts types" do
-    6.0.product_of(3,A).map{A}.should be_eql [2.0]
-  end
-
-  it "casts types" do
-    A.product_of(3,2.0).map{A}.should be_eql [6.0]
-  end
-
-  it "checks instatiation" do
-    expect { 8.product_of(B,C).map{[B,C]} }.to raise_error Rubylog::InstantiationError
-  end
-  
-  it "checks instatiation" do
-    expect { 8.sum_of(B,C).map{[B,C]} }.to raise_error Rubylog::InstantiationError
-  end
-
-  it "checks instatiation" do
-    expect { A.sum_of(B,2).map{[B,C]} }.to raise_error Rubylog::InstantiationError
-  end
-
-  it "checks instatiation" do
-    expect { A.product_of(B,2).map{[B,C]} }.to raise_error Rubylog::InstantiationError
+module RubylogSpec
+  describe "Arithmetics builtins", :rubylog=>true do
+    check 5.sum_of 2, 3
+
+    check((5.sum_of 2, 6).false)
+
+    check { 5.sum_of(3, A).map{A}.eql? [2] }
+    check { 5.sum_of(A, 2).map{A}.eql? [3] }
+    check { A.sum_of(3, 4).map{A}.eql? [7] }
+
+    check A.is(5).and B.is(3).and C.is(2).and A.sum_of(C, B)
+
+    it "works with functions" do
+      check A.is(5).and 5.sum_of(proc{2}, proc{A-2})
+      check A.is(5).and 5.sum_of(proc{3}, proc{A-2}).false
+    end
+
+    it "checks types" do
+      check 4.sum_of(2,2.0).false
+      check 4.0.sum_of(2.0,2.0)
+    end
+
+    it "can add strings" do
+      A.sum_of(B,C).predicate.add_functor_to String
+      check "hello".sum_of("he", "llo")
+    end
+
+    it "can add arrays" do
+      A.sum_of(B,C).predicate.add_functor_to Array
+      check [1,2,3].sum_of([1,2], [3])
+    end
+
+    it "can subtract arrays" do
+      A.sum_of(B,C).predicate.add_functor_to Array
+      [1,2,3].sum_of(X, [3]).map{X}.should be_eql [[1,2]]
+    end
+
+    it "can multiply integers" do
+      A.product_of(3,2).map{A}.should be_eql [6]
+    end
+
+    it "can divide integers" do
+      6.product_of(A,2).map{A}.should be_eql [3]
+    end
+
+    it "can divide integers" do
+      6.product_of(3,A).map{A}.should be_eql [2]
+    end
+
+    it "can divide floats" do
+      6.0.product_of(A,2.0).map{A}.should be_eql [3.0]
+    end
+
+    it "can divide floats" do
+      6.0.product_of(3.0,A).map{A}.should be_eql [2.0]
+    end
+
+    it "checks non-divisibility of integers" do
+      6.product_of(5,A).map{A}.should be_eql []
+    end
+
+    it "checks non-divisibility of integers" do
+      6.product_of(A,4).map{A}.should be_eql []
+    end
+
+    it "casts types" do
+      6.0.product_of(A,2).map{A}.should be_eql [3.0]
+    end
+
+    it "casts types" do
+      6.0.product_of(3,A).map{A}.should be_eql [2.0]
+    end
+
+    it "casts types" do
+      A.product_of(3,2.0).map{A}.should be_eql [6.0]
+    end
+
+    it "checks instatiation" do
+      expect { 8.product_of(B,C).map{[B,C]} }.to raise_error Rubylog::InstantiationError
+    end
+    
+    it "checks instatiation" do
+      expect { 8.sum_of(B,C).map{[B,C]} }.to raise_error Rubylog::InstantiationError
+    end
+
+    it "checks instatiation" do
+      expect { A.sum_of(B,2).map{[B,C]} }.to raise_error Rubylog::InstantiationError
+    end
+
+    it "checks instatiation" do
+      expect { A.product_of(B,2).map{[B,C]} }.to raise_error Rubylog::InstantiationError
+    end
   end
 end