rubylog 2.0.1 → 2.1.0

data/spec/rubylog/builtins/reflection_spec.rb

@@ -1,43 +1,45 @@
 require "spec_helper"
 require "rubylog/builtins/reflection"
 
-describe "reflection builtins", :rubylog => true do
-  before do
-    predicate_for String, ".likes() .drinks()"
-  end
+module RubylogSpec
+  describe "reflection builtins", :rubylog => true do
+    before do
+      predicate_for String, ".likes() .drinks()"
+    end
 
-  describe "fact" do
-    specify do
-      "John".likes! "beer"
-      check "John".likes("beer").fact
-      check { A.likes(B).fact.map{A.likes(B)} == ["John".likes("beer")] }
+    describe "fact" do
+      specify do
+        "John".likes! "beer"
+        check "John".likes("beer").fact
+        check { A.likes(B).fact.map{A.likes(B)} == ["John".likes("beer")] }
+      end
     end
-  end
 
-  describe "follows_from" do
-    specify do
-      A.drinks(B).if A.likes(B)
-      check A.drinks(B).follows_from A.likes(B)
-      check {A.drinks(B).follows_from(K).map{K} == [A.likes(B)] }
+    describe "follows_from" do
+      specify do
+        A.drinks(B).if A.likes(B)
+        check A.drinks(B).follows_from A.likes(B)
+        check {A.drinks(B).follows_from(K).map{K} == [A.likes(B)] }
+      end
     end
-  end
 
-  describe "structure" do
-    specify do
-      check A.likes(B).structure(A.likes(B).predicate, :likes, [A,B])
-      check { A.likes(B).structure(P,X,Y).map{[P,X,Y]} == [[A.likes.predicate, :likes, [A,B]]] }
+    describe "structure" do
+      specify do
+        check A.likes(B).structure(A.likes(B).predicate, :likes, [A,B])
+        check { A.likes(B).structure(P,X,Y).map{[P,X,Y]} == [[A.likes.predicate, :likes, [A,B]]] }
+      end
     end
-  end
 
-  describe "structures with variable functor and partial argument list" do
-    specify do
-      check { K.structure(ANY.drinks(ANY).predicate, :drinks, ["John", "beer"]).map{K} == ["John".drinks("beer")] }
-      check { K.structure(Rubylog::Procedure.new(:drinks, 2), A,[*B]).
-        and(A.is(:drinks)).
-        and(B.is(["John","beer"])).
-        map{K} == ["John".drinks("beer")] }
+    describe "structures with variable functor and partial argument list" do
+      specify do
+        check { K.structure(ANY.drinks(ANY).predicate, :drinks, ["John", "beer"]).map{K} == ["John".drinks("beer")] }
+        check { K.structure(Rubylog::Procedure.new(:drinks, 2), A,[*B]).
+          and(A.is(:drinks)).
+          and(B.is(["John","beer"])).
+          map{K} == ["John".drinks("beer")] }
+      end
     end
-  end
 
 
+  end
 end

data/spec/rubylog/builtins/term_spec.rb

@@ -1,81 +1,83 @@
 require 'spec_helper'
 
-describe "Term builtins", :rubylog => true do
-  before do
-    predicate_for Symbol, ".likes"
-  end
-
-  describe "in" do
+module RubylogSpec
+  describe "Term builtins", :rubylog => true do
     before do
-      :john.likes! :beer
-      :jane.likes! :milk
+      predicate_for Symbol, ".likes"
     end
 
-    it "works for variables" do
-      (A.likes(B).and(B.in [])).map{[A,B]}.should == []
-      (A.likes(B).and(B.in [:milk])).map{[A,B]}.should == [[:jane, :milk]]
-      (A.likes(B).and(B.in [:beer])).map{[A,B]}.should == [[:john, :beer]]
-      (A.likes(B).and(B.in [:milk, :beer])).map{[A,B]}.should == [[:john, :beer], [:jane, :milk]]
-    end
+    describe "in" do
+      before do
+        :john.likes! :beer
+        :jane.likes! :milk
+      end
 
-    it "works with blocks" do
-      (A.likes(B).and(B.in {[]})).map{[A,B]}.should == []
-      (A.likes(B).and(B.in {[A,:milk]})).map{[A,B]}.should == [[:jane, :milk]]
-      (A.likes(B).and(B.in {[:beer]})).map{[A,B]}.should == [[:john, :beer]]
-      (A.likes(B).and(B.in {[B]})).map{[A,B]}.should == [[:john, :beer], [:jane, :milk]]
-    end
+      it "works for variables" do
+        (A.likes(B).and(B.in [])).map{[A,B]}.should == []
+        (A.likes(B).and(B.in [:milk])).map{[A,B]}.should == [[:jane, :milk]]
+        (A.likes(B).and(B.in [:beer])).map{[A,B]}.should == [[:john, :beer]]
+        (A.likes(B).and(B.in [:milk, :beer])).map{[A,B]}.should == [[:john, :beer], [:jane, :milk]]
+      end
 
-    it "works as iterator" do
-      (A.in{[1,3,4]}).map{A}.should == [1,3,4]
-      (A.in [1,3,4]).map{A}.should == [1,3,4]
-    end
+      it "works with blocks" do
+        (A.likes(B).and(B.in {[]})).map{[A,B]}.should == []
+        (A.likes(B).and(B.in {[A,:milk]})).map{[A,B]}.should == [[:jane, :milk]]
+        (A.likes(B).and(B.in {[:beer]})).map{[A,B]}.should == [[:john, :beer]]
+        (A.likes(B).and(B.in {[B]})).map{[A,B]}.should == [[:john, :beer], [:jane, :milk]]
+      end
 
-    it "works as search" do
-      (1.in{[1,3,4]}).to_a.should == [nil]
-      (2.in{[1,3,4]}).to_a.should == []
-      (1.in [1,3,4]).to_a.should == [nil]
-      (2.in [1,3,4]).to_a.should == []
-    end
+      it "works as iterator" do
+        (A.in{[1,3,4]}).map{A}.should == [1,3,4]
+        (A.in [1,3,4]).map{A}.should == [1,3,4]
+      end
 
-    it "checks instatiation" do
-      expect { 5.in(B).map{B} }.to raise_error Rubylog::InstantiationError
-    end
+      it "works as search" do
+        (1.in{[1,3,4]}).to_a.should == [nil]
+        (2.in{[1,3,4]}).to_a.should == []
+        (1.in [1,3,4]).to_a.should == [nil]
+        (2.in [1,3,4]).to_a.should == []
+      end
 
-  end
+      it "checks instatiation" do
+        expect { 5.in(B).map{B} }.to raise_error Rubylog::InstantiationError
+      end
 
-  describe "not_in" do
-    specify do
-      (1.not_in{[1,3,4]}).to_a.should == []
-      (2.not_in{[1,3,4]}).to_a.should == [nil]
-      (1.not_in [1,3,4]).to_a.should == []
-      (2.not_in [1,3,4]).to_a.should == [nil]
     end
-  end
 
-  describe "is" do
-    before do
-      :john.likes! :beer
-      :jane.likes! :milk
+    describe "not_in" do
+      specify do
+        (1.not_in{[1,3,4]}).to_a.should == []
+        (2.not_in{[1,3,4]}).to_a.should == [nil]
+        (1.not_in [1,3,4]).to_a.should == []
+        (2.not_in [1,3,4]).to_a.should == [nil]
+      end
     end
 
-    it "works for variables" do
-      (A.likes(B).and(B.is :milk)).map{[A,B]}.should == [[:jane, :milk]]
-      (A.likes(B).and(:milk.is B)).map{[A,B]}.should == [[:jane, :milk]]
-    end
+    describe "is" do
+      before do
+        :john.likes! :beer
+        :jane.likes! :milk
+      end
 
-    it "works as calculation" do
-      (A.is {|| 4+4}).map{A}.should == [8]
-      (A.is {4+4}).map{A}.should == [8]
-      (A.is(4).and A.is{2*2}).map{A}.should == [4]
-      (A.is(4).and A.is{2*3}).map{A}.should == []
-    end
+      it "works for variables" do
+        (A.likes(B).and(B.is :milk)).map{[A,B]}.should == [[:jane, :milk]]
+        (A.likes(B).and(:milk.is B)).map{[A,B]}.should == [[:jane, :milk]]
+      end
+
+      it "works as calculation" do
+        (A.is {|| 4+4}).map{A}.should == [8]
+        (A.is {4+4}).map{A}.should == [8]
+        (A.is(4).and A.is{2*2}).map{A}.should == [4]
+        (A.is(4).and A.is{2*3}).map{A}.should == []
+      end
+
+      it "works as calculation with vars" do
+        (A.is(4).and B.is{A*4}).map{[A,B]}.should == [[4,16]]
+        (A.is(4).and A.is{A*1}).map{A}.should == [4]
+        (A.is(4).and A.is{A*2}).map{A}.should == []
+      end
 
-    it "works as calculation with vars" do
-      (A.is(4).and B.is{A*4}).map{[A,B]}.should == [[4,16]]
-      (A.is(4).and A.is{A*1}).map{A}.should == [4]
-      (A.is(4).and A.is{A*2}).map{A}.should == []
     end
 
   end
-
 end

data/spec/rubylog/context_modules/demonstration_spec.rb

@@ -1,132 +1,134 @@
 require "spec_helper"
 
-describe "queries", :rubylog=>true do
-  before do
-    predicate_for Symbol, ".likes(Drink)"
-  end
-
-  it "can be run with true?" do
-    true?(:john.likes :beer).should be_false
-    :john.likes! :beer
-    true?(:john.likes :beer).should be_true
-  end
-
-  it "can be run with question mark" do
-    :john.likes?(:beer).should be_false
-    :john.likes! :beer
-    :john.likes?(:beer).should be_true
-  end
-
-  it "can be run with true?" do
-    (:john.likes(:beer)).true?.should be_false
-    :john.likes! :beer
-    (:john.likes(:beer)).true?.should be_true
-  end
+module RubylogSpec
+  describe "queries", :rubylog=>true do
+    before do
+      predicate_for Symbol, ".likes(Drink)"
+    end
 
-  it "can be run with solve" do
-    result = false
-    solve(:john.likes(:beer)) { result = true }
-    result.should == false
-    :john.likes! :beer
-    solve(:john.likes(:beer)) { result = true }
-    result.should == true
-  end
+    it "can be run with true?" do
+      true?(:john.likes :beer).should be_false
+      :john.likes! :beer
+      true?(:john.likes :beer).should be_true
+    end
 
-  it "work with variables" do
-    :john.likes?(X).should be_false
-    :john.likes! :water
-    :john.likes?(X).should be_true
-  end
+    it "can be run with question mark" do
+      :john.likes?(:beer).should be_false
+      :john.likes! :beer
+      :john.likes?(:beer).should be_true
+    end
 
-  it "yield all solutions" do
-    :john.likes! :beer
-    :john.likes! :milk
+    it "can be run with true?" do
+      (:john.likes(:beer)).true?.should be_false
+      :john.likes! :beer
+      (:john.likes(:beer)).true?.should be_true
+    end
 
-    k=[]
-    (:john.likes X).each{k << X}
-    k.should == [:beer, :milk]
-  end
+    it "can be run with solve" do
+      result = false
+      solve(:john.likes(:beer)) { result = true }
+      result.should == false
+      :john.likes! :beer
+      solve(:john.likes(:beer)) { result = true }
+      result.should == true
+    end
 
-  it "yield all solutions with solve" do
-    :john.likes! :beer
-    :john.likes! :milk
+    it "work with variables" do
+      :john.likes?(X).should be_false
+      :john.likes! :water
+      :john.likes?(X).should be_true
+    end
 
-    k=[]
-    (:john.likes X).solve{k << X}
-    k.should == [:beer, :milk]
-  end
+    it "yield all solutions" do
+      :john.likes! :beer
+      :john.likes! :milk
 
-  it "yield all solutions with solve and multiple vars and multiple block parameters" do
-    :john.likes! :beer
-    :jane.likes! :milk
-    :jane.likes! :water
+      k=[]
+      (:john.likes X).each{k << X}
+      k.should == [:beer, :milk]
+    end
 
-    k=[]
-    (X.likes Y).solve{k << [X,Y]}
-    k.should == [[:john, :beer], [:jane, :milk], [:jane, :water]]
-  end
+    it "yield all solutions with solve" do
+      :john.likes! :beer
+      :john.likes! :milk
 
-  it "ignore don't-care variables" do
-    :john.likes! :beer
+      k=[]
+      (:john.likes X).solve{k << X}
+      k.should == [:beer, :milk]
+    end
 
-    k=[]
-    ANYONE.likes(X).each{k << [ANYONE,X]}
-    k.should == [[ANYONE, :beer]]
+    it "yield all solutions with solve and multiple vars and multiple block parameters" do
+      :john.likes! :beer
+      :jane.likes! :milk
+      :jane.likes! :water
 
-    k=[]
-    X.likes(ANYTHING).each{k << [X,ANYTHING]}
-    k.should == [[:john, ANYTHING]]
-  end
+      k=[]
+      (X.likes Y).solve{k << [X,Y]}
+      k.should == [[:john, :beer], [:jane, :milk], [:jane, :water]]
+    end
 
-  it "leaves unboud variables as they are" do
-    res = []
-    A.likes(B).if {res << A << B }
-    A.likes? :beer
-    res.should eql [A,:beer]
-  end
+    it "ignore don't-care variables" do
+      :john.likes! :beer
 
-  it "substitutes deeper variables" do
-    res = []
-    A.likes(B).if {res << A << B; true}
-    (A.is(:john).and B.is(:swimming.in C).and \
-     C.is(:sea).and A.likes B).map{[A,B,C]}.should == [[:john,:swimming.in(:sea),:sea]]
-     res.should == [:john, :swimming.in(:sea)]
-  end
+      k=[]
+      ANYONE.likes(X).each{k << [ANYONE,X]}
+      k.should == [[ANYONE, :beer]]
 
-  it "leaves deeper unboud variables as they are" do
-    res = []
-    A.likes(B).if {res << A << B; true}
-    (A.is(:john).and B.is(:swimming.in C).and A.likes B).map{[A,B,C]}.should eql [[:john,:swimming.in(C),C]]
-    res.should == [:john, :swimming.in(C)]
-  end
+      k=[]
+      X.likes(ANYTHING).each{k << [X,ANYTHING]}
+      k.should == [[:john, ANYTHING]]
+    end
 
-  describe "support Enumerable" do
-    before do
-      :john.likes! :beer
-      :john.likes! :milk
+    it "leaves unboud variables as they are" do
+      res = []
+      A.likes(B).if {res << A << B }
+      A.likes? :beer
+      res.should eql [A,:beer]
     end
 
-    it "#all?, #any? and #none?" do
-      (:john.likes A).all?{Symbol===A}.should be_true
-      (:john.likes A).all?{A == :beer}.should be_false
-      (:john.likes A).all?{A == :beer or A == :milk}.should be_true
-      (:john.likes A).any?{A == :beer}.should be_true
-      (:john.likes A).any?{A == :milk}.should be_true
-      (:john.likes A).any?{A == :water}.should be_false
-      (:john.likes A).none?{A == :water}.should be_true
-      (:john.likes A).none?{A == :beer}.should be_false
+    it "substitutes deeper variables" do
+      res = []
+      A.likes(B).if {res << A << B; true}
+      (A.is(:john).and B.is(:swimming.in C).and \
+       C.is(:sea).and A.likes B).map{[A,B,C]}.should == [[:john,:swimming.in(:sea),:sea]]
+       res.should == [:john, :swimming.in(:sea)]
     end
 
-    it "#to_a" do
-      (:john.likes A).to_a.should == [nil, nil]
-      (X.likes A).to_a.should == [nil, nil]
-      (ANYONE.likes A).to_a.should == [nil, nil]
+    it "leaves deeper unboud variables as they are" do
+      res = []
+      A.likes(B).if {res << A << B; true}
+      (A.is(:john).and B.is(:swimming.in C).and A.likes B).map{[A,B,C]}.should eql [[:john,:swimming.in(C),C]]
+      res.should == [:john, :swimming.in(C)]
     end
 
-    it "#map" do
-      (:john.likes A).map{A.to_s}.should == ['beer', 'milk']
+    describe "support Enumerable" do
+      before do
+        :john.likes! :beer
+        :john.likes! :milk
+      end
+
+      it "#all?, #any? and #none?" do
+        (:john.likes A).all?{Symbol===A}.should be_true
+        (:john.likes A).all?{A == :beer}.should be_false
+        (:john.likes A).all?{A == :beer or A == :milk}.should be_true
+        (:john.likes A).any?{A == :beer}.should be_true
+        (:john.likes A).any?{A == :milk}.should be_true
+        (:john.likes A).any?{A == :water}.should be_false
+        (:john.likes A).none?{A == :water}.should be_true
+        (:john.likes A).none?{A == :beer}.should be_false
+      end
+
+      it "#to_a" do
+        (:john.likes A).to_a.should == [nil, nil]
+        (X.likes A).to_a.should == [nil, nil]
+        (ANYONE.likes A).to_a.should == [nil, nil]
+      end
+
+      it "#map" do
+        (:john.likes A).map{A.to_s}.should == ['beer', 'milk']
+      end
+
     end
 
   end
-
-end
+end