rubylog 2.0.1 → 2.1.0

data/spec/rubylog/mixins/array_spec.rb

@@ -1,80 +1,82 @@
 require 'spec_helper'
 
-describe Array, :rubylog=>true do
-
-  describe "unification" do
-    def can_unify a, b
-      result = false
-      a.rubylog_unify(b) { result = true; yield if block_given? }
-      result.should == true
-    end
+module RubylogSpec
+  describe Array, :rubylog=>true do
+
+    describe "unification" do
+      def can_unify a, b
+        result = false
+        a.rubylog_unify(b) { result = true; yield if block_given? }
+        result.should == true
+      end
 
-    def cannot_unify a, b
-      result = false
-      a.rubylog_unify(b) { result = true }
-      result.should == false
-    end
+      def cannot_unify a, b
+        result = false
+        a.rubylog_unify(b) { result = true }
+        result.should == false
+      end
 
-    it "does not unify with non-array" do
-      cannot_unify [A,B], 12
-    end
+      it "does not unify with non-array" do
+        cannot_unify [A,B], 12
+      end
 
-    it "unifies empty arrays" do
-      can_unify [], []
-    end
+      it "unifies empty arrays" do
+        can_unify [], []
+      end
 
-    it "unifies empty array with splat" do
-      a = A
-      can_unify [], [*a] do
-        a.value.should == []
+      it "unifies empty array with splat" do
+        a = A
+        can_unify [], [*a] do
+          a.value.should == []
+        end
       end
-    end
 
-    it "unifies two splats" do
-      a = A
-      b = B
-      can_unify [*a], [*b] do
-        a.value.should equal b
+      it "unifies two splats" do
+        a = A
+        b = B
+        can_unify [*a], [*b] do
+          a.value.should equal b
+        end
       end
-    end
 
-    it "unifies two arrays with splats at the first element" do
-      a = A
-      b = B
-      can_unify [*a], [*b,5] do
-        a.value.should eql [*b,5]
+      it "unifies two arrays with splats at the first element" do
+        a = A
+        b = B
+        can_unify [*a], [*b,5] do
+          a.value.should eql [*b,5]
+        end
       end
-    end
 
-    it "unifies a splat with empty array" do
-      a = A
-      can_unify [*a], [] do
-        a.value.should eql []
+      it "unifies a splat with empty array" do
+        a = A
+        can_unify [*a], [] do
+          a.value.should eql []
+        end
       end
-    end
 
-    it "unififes splats at first elements" do
-      A.is([1,2,3]).and([*A,4].is([*B,*ANY])).map{B}.should ==
-        [[],[1],[1,2],[1,2,3],[1,2,3,4]]
-    end
+      it "unififes splats at first elements" do
+        A.is([1,2,3]).and([*A,4].is([*B,*ANY])).map{B}.should ==
+          [[],[1],[1,2],[1,2,3],[1,2,3,4]]
+      end
 
-    it "unififes first splat with first non-splat" do
-      A.is([1,2,3]).and([*A,4].is([X,*C])).map{[X,C]}.should ==
-        [[1,[2,3,4]]]
-    end
+      it "unififes first splat with first non-splat" do
+        A.is([1,2,3]).and([*A,4].is([X,*C])).map{[X,C]}.should ==
+          [[1,[2,3,4]]]
+      end
 
-    it "unififes first empty splat with first non-splat" do
-      A.is([]).and([*A,4].is([X,*C])).map{[X,C]}.should ==
-        [[4,[]]]
-    end
+      it "unififes first empty splat with first non-splat" do
+        A.is([]).and([*A,4].is([X,*C])).map{[X,C]}.should ==
+          [[4,[]]]
+      end
 
 
-  end
+    end
 
-  describe "#rubylog_deep_dereference" do
-    it "does keeps unbound splats" do
-      [*A].rubylog_deep_dereference.should eql [*A]
+    describe "#rubylog_deep_dereference" do
+      it "does keeps unbound splats" do
+        [*A].rubylog_deep_dereference.should eql [*A]
+      end
     end
-  end
 
+  end
 end

data/spec/rubylog/mixins/composite_term_spec.rb

@@ -1,66 +1,68 @@
 require "spec_helper"
 
-describe Rubylog::CompoundTerm, :rubylog=>true do
-  predicate_for Symbol, ".likes()"
+module RubylogSpec
+  describe Rubylog::CompoundTerm, :rubylog=>true do
+    predicate_for Symbol, ".likes()"
 
-  describe "compilation" do
+    describe "compilation" do
 
-    it "makes eql variables be equal" do
-      a = A; b = A
-      c = (a.likes b)
-      c[0].should be_equal a; c[1].should be_equal b
-      c[0].should_not be_equal c[1]
-      c = c.rubylog_match_variables
-      c[0].should be_equal c[1]
-    end
+      it "makes eql variables be equal" do
+        a = A; b = A
+        c = (a.likes b)
+        c[0].should be_equal a; c[1].should be_equal b
+        c[0].should_not be_equal c[1]
+        c = c.rubylog_match_variables
+        c[0].should be_equal c[1]
+      end
 
-    it "makes non-eql variables be non-equal" do
-      a = A; b = B
-      c = (a.likes b)
-      c[0].should be_equal a; c[1].should be_equal b
-      c[0].should_not be_equal c[1]
-      c = c.rubylog_match_variables
-      c[0].should_not be_equal c[1]
-    end
+      it "makes non-eql variables be non-equal" do
+        a = A; b = B
+        c = (a.likes b)
+        c[0].should be_equal a; c[1].should be_equal b
+        c[0].should_not be_equal c[1]
+        c = c.rubylog_match_variables
+        c[0].should_not be_equal c[1]
+      end
 
-    it "makes dont-care variables be non-equal" do
-      a = ANY; b = ANY
-      c = (a.likes b)
-      c[0].should be_equal a; c[1].should be_equal b
-      c[0].should_not be_equal c[1]
-      c = c.rubylog_match_variables
-      c[0].should_not be_equal c[1]
-    end
+      it "makes dont-care variables be non-equal" do
+        a = ANY; b = ANY
+        c = (a.likes b)
+        c[0].should be_equal a; c[1].should be_equal b
+        c[0].should_not be_equal c[1]
+        c = c.rubylog_match_variables
+        c[0].should_not be_equal c[1]
+      end
 
-    it "creates new variables" do
-      a = A; b = B
-      c = (a.likes b)
-      c[0].should be_equal a; c[1].should be_equal b
-      c = c.rubylog_match_variables
-      c[0].should_not be_equal a
-      c[1].should_not be_equal a
-      c[0].should_not be_equal b
-      c[1].should_not be_equal b
-    end
+      it "creates new variables" do
+        a = A; b = B
+        c = (a.likes b)
+        c[0].should be_equal a; c[1].should be_equal b
+        c = c.rubylog_match_variables
+        c[0].should_not be_equal a
+        c[1].should_not be_equal a
+        c[0].should_not be_equal b
+        c[1].should_not be_equal b
+      end
 
-    it "makes variables available" do
-      a = A; a1 = A; a2 = A; b = B; b1 = B; c = C;
-      (a.likes b).rubylog_match_variables.rubylog_variables.should == [a, b]
-      (a.likes a1).rubylog_match_variables.rubylog_variables.should == [a]
-      (a.likes a1.in b).rubylog_match_variables.rubylog_variables.should == [a, b]
-      (a.likes a1,b,b1,a2,c).rubylog_match_variables.rubylog_variables.should == [a, b, c]
-    end
+      it "makes variables available" do
+        a = A; a1 = A; a2 = A; b = B; b1 = B; c = C;
+        (a.likes b).rubylog_match_variables.rubylog_variables.should == [a, b]
+        (a.likes a1).rubylog_match_variables.rubylog_variables.should == [a]
+        (a.likes a1.in b).rubylog_match_variables.rubylog_variables.should == [a, b]
+        (a.likes a1,b,b1,a2,c).rubylog_match_variables.rubylog_variables.should == [a, b, c]
+      end
 
-    it "does not make dont-care variables available" do
-      a = ANY; a1 = ANYTHING; a2 = ANYTHING; b = B; b1 = B; c = C;
-      (a.likes b).rubylog_match_variables.rubylog_variables.should == [b]
-      (a.likes a1).rubylog_match_variables.rubylog_variables.should == []
-      (a.likes a1.in b).rubylog_match_variables.
-        rubylog_variables.should == [b]
-      (a.likes a1,b,b1,a2,c).rubylog_match_variables.
-        rubylog_variables.should == [b, c]
-    end
+      it "does not make dont-care variables available" do
+        a = ANY; a1 = ANYTHING; a2 = ANYTHING; b = B; b1 = B; c = C;
+        (a.likes b).rubylog_match_variables.rubylog_variables.should == [b]
+        (a.likes a1).rubylog_match_variables.rubylog_variables.should == []
+        (a.likes a1.in b).rubylog_match_variables.
+          rubylog_variables.should == [b]
+        (a.likes a1,b,b1,a2,c).rubylog_match_variables.
+          rubylog_variables.should == [b, c]
+      end
 
 
+    end
   end
 end

data/spec/rubylog/mixins/proc_spec.rb

@@ -1,59 +1,61 @@
 require "spec_helper"
 
-describe Proc, :rubylog=>true do
-  before do
-    predicate_for Symbol, ".is_happy .likes()"
-  end
-
-  describe "using ruby code in clauses" do
-    it "works" do
-      (:true.and? {false}).should be_false
-      (:true.and? {true}).should be_true
-      (:fail.and? {false}).should be_false
-      (:fail.and? {true}).should be_false
-      (:true.or? {false}).should be_true
-      (:true.or? {true}).should be_true
-      (:fail.or? {false}).should be_false
-      (:fail.or? {true}).should be_true
-
-      (:fail.or? {false}).should be_false
-      (:fail.or? {true}).should be_true
-    end
-    it "runs the query once at every evaluation" do
-      count = 0
-      :john.is_happy.if :true.and { count += 1 }
-      count.should == 0
-      :john.is_happy?
-      count.should == 1
-      :john.is_happy?
-      count.should == 2
-      (:fail.or? {count+=1}).should be_true
-      count.should == 3
+module RubylogSpec
+  describe Proc, :rubylog=>true do
+    before do
+      predicate_for Symbol, ".is_happy .likes()"
     end
 
-    describe "bindings" do
-      it "works for rule bodies" do
-        result = nil; 
-        (A.likes(B).if {result = [A,B]})
-        (:john.likes(:beer)).solve{}
-        result.should == [:john,:beer]
+    describe "using ruby code in clauses" do
+      it "works" do
+        (:true.and? {false}).should be_false
+        (:true.and? {true}).should be_true
+        (:fail.and? {false}).should be_false
+        (:fail.and? {true}).should be_false
+        (:true.or? {false}).should be_true
+        (:true.or? {true}).should be_true
+        (:fail.or? {false}).should be_false
+        (:fail.or? {true}).should be_true
+
+        (:fail.or? {false}).should be_false
+        (:fail.or? {true}).should be_true
       end
-
-      it "works for rules" do
-        result = nil
-        (A.likes(B).if B.is(4).and A.is(2).and C.is(5).and {result = [A,B,C]})
-        (A.likes(B)).solve{}
-        result.should == [2,4,5]
+      it "runs the query once at every evaluation" do
+        count = 0
+        :john.is_happy.if :true.and { count += 1 }
+        count.should == 0
+        :john.is_happy?
+        count.should == 1
+        :john.is_happy?
+        count.should == 2
+        (:fail.or? {count+=1}).should be_true
+        count.should == 3
       end
 
-      it "works for inline terms" do
-        result = nil
-        (A.is(1).and B.is(2).and {result = [A,B]}).solve{}
-        result.should == [1,2]
-      end
+      describe "bindings" do
+        it "works for rule bodies" do
+          result = nil; 
+          (A.likes(B).if {result = [A,B]})
+          (:john.likes(:beer)).solve{}
+          result.should == [:john,:beer]
+        end
+
+        it "works for rules" do
+          result = nil
+          (A.likes(B).if B.is(4).and A.is(2).and C.is(5).and {result = [A,B,C]})
+          (A.likes(B)).solve{}
+          result.should == [2,4,5]
+        end
 
+        it "works for inline terms" do
+          result = nil
+          (A.is(1).and B.is(2).and {result = [A,B]}).solve{}
+          result.should == [1,2]
+        end
 
 
+
+      end
     end
   end
 end

data/spec/rubylog/mixins/string_spec.rb

@@ -1,48 +1,50 @@
 require "spec_helper"
 
-describe String, :rubylog=>true do
-  describe "unification" do
-    check "asdf".is "asdf"
-    check { "abc#{S}def" =~ /abc.S\[\].def/ }
-    check { "abc#{S[length: 1]}def" =~ /abc.S\[\d+\].def/ }
-    check { "h#{S}o".is("hello").map{S} == ["ell"] }
-    check { "#{Base}.#{Ext}".is("hello.rb").map{Base} == ["hello"] }
-    check { "#{Base}.#{Ext}".is("hello.rb").map{Ext} == ["rb"] }
-    check { "h#{S}o".is("auto").map{S} == [] }
-  end
-
-  describe "backtracked matches" do
-    check { "abc".is("#{A}#{B}").map{"#{A}:#{B}"} == [":abc","a:bc","ab:c","abc:"] }
-    check { "www.google.com".is("#{A}.#{B}").map{[A,B]} == [["www", "google.com"],["www.google", "com"]] }
-    check { "a".is("#{A}#{B}#{C}").map{"#{A}:#{B}:#{C}"} == ["::a",":a:","a::"] }
-    check { "ab".is("#{A}#{B}#{C}").map{"#{A}:#{B}:#{C}"} == %w(::ab :a:b :ab: a::b a:b: ab::) }
-  end
+module RubylogSpec
+  describe String, :rubylog=>true do
+    describe "unification" do
+      check "asdf".is "asdf"
+      check { "abc#{S}def" =~ /abc.S\[\].def/ }
+      check { "abc#{S[length: 1]}def" =~ /abc.S\[\d+\].def/ }
+      check { "h#{S}o".is("hello").map{S} == ["ell"] }
+      check { "#{Base}.#{Ext}".is("hello.rb").map{Base} == ["hello"] }
+      check { "#{Base}.#{Ext}".is("hello.rb").map{Ext} == ["rb"] }
+      check { "h#{S}o".is("auto").map{S} == [] }
+    end
+
+    describe "backtracked matches" do
+      check { "abc".is("#{A}#{B}").map{"#{A}:#{B}"} == [":abc","a:bc","ab:c","abc:"] }
+      check { "www.google.com".is("#{A}.#{B}").map{[A,B]} == [["www", "google.com"],["www.google", "com"]] }
+      check { "a".is("#{A}#{B}#{C}").map{"#{A}:#{B}:#{C}"} == ["::a",":a:","a::"] }
+      check { "ab".is("#{A}#{B}#{C}").map{"#{A}:#{B}:#{C}"} == %w(::ab :a:b :ab: a::b a:b: ab::) }
+    end
+
+    describe "guards" do
+      check { "abc".is("#{A[/\A.\z/]}#{B}").map{"#{A}:#{B}"} == ["a:bc"] }
+      check { "abc".is("#{A[length: 1]}#{B}").map{"#{A}:#{B}"} == ["a:bc"] }
+    end
+
+
+    describe "palindromes" do
+      predicate_for String, ".palindrome"
+
+      S[empty?: true].palindrome!
+      S[length: 1].palindrome!
+      S[lambda{|s|s.length > 1}].palindrome.if S.is("#{A[length: 1]}#{B}#{A}").and B.palindrome
+
+      check "".palindrome
+      check "dd".palindrome
+      check "aba".palindrome
+      check "faaf".palindrome
+      check "ffaaff".palindrome
+      check "rererer".palindrome
+      check "lol".palindrome
+      check "ji".palindrome.false
+      check "doo".palindrome.false
+      check "taaaz".palindrome.false
+      check "faad".palindrome.false
+      check "rerere".palindrome.false
+    end
 
-  describe "guards" do
-    check { "abc".is("#{A[/\A.\z/]}#{B}").map{"#{A}:#{B}"} == ["a:bc"] }
-    check { "abc".is("#{A[length: 1]}#{B}").map{"#{A}:#{B}"} == ["a:bc"] }
   end
-
-
-  describe "palindromes" do
-    predicate_for String, ".palindrome"
-
-    S[empty?: true].palindrome!
-    S[length: 1].palindrome!
-    S[lambda{|s|s.length > 1}].palindrome.if S.is("#{A[length: 1]}#{B}#{A}").and B.palindrome
-
-    check "".palindrome
-    check "dd".palindrome
-    check "aba".palindrome
-    check "faaf".palindrome
-    check "ffaaff".palindrome
-    check "rererer".palindrome
-    check "lol".palindrome
-    check "ji".palindrome.false
-    check "doo".palindrome.false
-    check "taaaz".palindrome.false
-    check "faad".palindrome.false
-    check "rerere".palindrome.false
-  end
-
 end