rubylog 2.0.1 → 2.1.0

data/spec/rubylog/context_modules/predicates_spec.rb

@@ -1,35 +1,37 @@
 require "spec_helper" 
 
-describe Rubylog::ContextModules::Predicates, :rubylog=>true do
-  describe "#predicate_for" do
+module RubylogSpec
+  describe Rubylog::ContextModules::Predicates, :rubylog=>true do
+    describe "#predicate_for" do
 
-    specify "can accept humanized predicate" do
-      predicate_for String, ".long"
-      L.long.if { L.length > 10 }
-      "0123456789".should_not be_long
-      "01234567890".should be_long
-    end
+      specify "can accept humanized predicate" do
+        predicate_for String, ".long"
+        L.long.if { L.length > 10 }
+        "0123456789".should_not be_long
+        "01234567890".should be_long
+      end
 
-    specify "can accept space-separated predicates" do
-      predicate_for String, ".long .short"
-      L.long.if { L.length > 10 }
-      L.short.unless L.long
-      "01234567890".should_not be_short
-    end
-    
-    specify "can accept list of predicates" do
-      predicate_for String, ".long", ".short"
-      L.long.if { L.length > 10 }
-      L.short.unless L.long
-      "01234567890".should_not be_short
-    end
+      specify "can accept space-separated predicates" do
+        predicate_for String, ".long .short"
+        L.long.if { L.length > 10 }
+        L.short.unless L.long
+        "01234567890".should_not be_short
+      end
+      
+      specify "can accept list of predicates" do
+        predicate_for String, ".long", ".short"
+        L.long.if { L.length > 10 }
+        L.short.unless L.long
+        "01234567890".should_not be_short
+      end
 
-    specify "can accept array of predicates" do
-      predicate_for String, %w".long .short"
-      L.long.if { L.length > 10 }
-      L.short.unless L.long
-      "01234567890".should_not be_short
+      specify "can accept array of predicates" do
+        predicate_for String, %w".long .short"
+        L.long.if { L.length > 10 }
+        L.short.unless L.long
+        "01234567890".should_not be_short
+      end
     end
-  end
 
+  end
 end

data/spec/rubylog/context_modules/thats_spec.rb

@@ -1,94 +1,96 @@
 require "spec_helper"
 require "rubylog/builtins/file_system"
 
-describe "thats", :rubylog=>true do
-  describe "one level" do
-    check 4.is(ANY[Integer,thats < 10])
-    check 4.is(ANY[Integer,thats < 5])
-    check 4.is(ANY[Integer,thats < 4]).false
-    check 4.is(ANY[Integer,thats < 2]).false
-  end
+module RubylogSpec
+  describe "thats", :rubylog=>true do
+    describe "one level" do
+      check 4.is(ANY[Integer,thats < 10])
+      check 4.is(ANY[Integer,thats < 5])
+      check 4.is(ANY[Integer,thats < 4]).false
+      check 4.is(ANY[Integer,thats < 2]).false
+    end
 
-  describe "question mark" do
-    check "".is(ANY[thats.empty?])
-    check "a".is(ANY[thats.empty?]).false
-  end
+    describe "question mark" do
+      check "".is(ANY[thats.empty?])
+      check "a".is(ANY[thats.empty?]).false
+    end
 
-  describe "two levels" do
-    check "hello".is(ANYTHING[thats.reverse == "olleh"])
-    check "hello".is(ANYTHING[thats.reverse == "olle"]).false
-  end
+    describe "two levels" do
+      check "hello".is(ANYTHING[thats.reverse == "olleh"])
+      check "hello".is(ANYTHING[thats.reverse == "olle"]).false
+    end
 
-  describe "four levels" do
-    check "hello".is(ANY[thats.upcase.partition("E")[0] == "H"])
-    check "hello".is(ANY[thats.upcase.partition("E")[1] == "E"])
-    check "hello".is(ANY[thats.upcase.partition("E")[2] == "LLO"])
-    check "hello".is(ANY[thats.upcase.partition("E")[1] == "H"]).false
-    check "hello".is(ANY[thats.upcase.partition("E")[0] == "h"]).false
-    check "hello".is(ANY[thats.upcase.partition("L")[0] == "H"]).false
-    check "hello".is(ANY[thats.upcase.partition("e")[0] == "H"]).false
-  end
+    describe "four levels" do
+      check "hello".is(ANY[thats.upcase.partition("E")[0] == "H"])
+      check "hello".is(ANY[thats.upcase.partition("E")[1] == "E"])
+      check "hello".is(ANY[thats.upcase.partition("E")[2] == "LLO"])
+      check "hello".is(ANY[thats.upcase.partition("E")[1] == "H"]).false
+      check "hello".is(ANY[thats.upcase.partition("E")[0] == "h"]).false
+      check "hello".is(ANY[thats.upcase.partition("L")[0] == "H"]).false
+      check "hello".is(ANY[thats.upcase.partition("e")[0] == "H"]).false
+    end
 
-  describe "files" do
-    check {     "#{S[String, thats.start_with?(".")]}".filename_in(".").map{S}.include? ".gitignore" }
-    check { not "#{S[String, thats.start_with?(".")]}". dirname_in(".").map{S}.include? "lib" }
-    specify { "#{S[/\A(.*)\.rb/]}".filename_in("lib").map{S}.should == ["rubylog.rb"] }
-  end
+    describe "files" do
+      check {     "#{S[String, thats.start_with?(".")]}".filename_in(".").map{S}.include? ".gitignore" }
+      check { not "#{S[String, thats.start_with?(".")]}". dirname_in(".").map{S}.include? "lib" }
+      specify { "#{S[/\A(.*)\.rb/]}".filename_in("lib").map{S}.should == ["rubylog.rb"] }
+    end
 
-  describe "factorial" do
-    predicate_for Integer, ".factorial()"
-    0.factorial! 1
-    K[thats > 0].factorial(N).if K0.is{K-1}.and K0.factorial(N0).and N.is{N0*K}
-  end
+    describe "factorial" do
+      predicate_for Integer, ".factorial()"
+      0.factorial! 1
+      K[thats > 0].factorial(N).if K0.is{K-1}.and K0.factorial(N0).and N.is{N0*K}
+    end
+
+    describe "palindrome" do
+      predicate_for String, ".palindrome"
+      S[String, thats.length <= 1].palindrome!
+      "#{A[thats.length == 1]}#{B}#{A}".palindrome.if B.palindrome
 
-  describe "palindrome" do
-    predicate_for String, ".palindrome"
-    S[String, thats.length <= 1].palindrome!
-    "#{A[thats.length == 1]}#{B}#{A}".palindrome.if B.palindrome
+      check "a".palindrome
+      check "aa".palindrome
+      check "aga".palindrome
+      check "aaa".palindrome
+      check "avava".palindrome
+      check "ab".palindrome.false
+      check "abb".palindrome.false
+      check "abab".palindrome.false
+    end
 
-    check "a".palindrome
-    check "aa".palindrome
-    check "aga".palindrome
-    check "aaa".palindrome
-    check "avava".palindrome
-    check "ab".palindrome.false
-    check "abb".palindrome.false
-    check "abab".palindrome.false
   end
 
-end
+  describe "thats_not", :rubylog=>true do
+    describe "one level" do
+      check 4.is(ANY[Integer,thats_not < 10]).false
+      check 4.is(ANY[Integer,thats_not < 5]).false
+      check 4.is(ANY[Integer,thats_not < 4])
+      check 4.is(ANY[Integer,thats_not < 2])
+    end
 
-describe "thats_not", :rubylog=>true do
-  describe "one level" do
-    check 4.is(ANY[Integer,thats_not < 10]).false
-    check 4.is(ANY[Integer,thats_not < 5]).false
-    check 4.is(ANY[Integer,thats_not < 4])
-    check 4.is(ANY[Integer,thats_not < 2])
-  end
+    describe "question mark" do
+      check "".is(ANY[thats_not.empty?]).false
+      check "a".is(ANY[thats_not.empty?])
+    end
 
-  describe "question mark" do
-    check "".is(ANY[thats_not.empty?]).false
-    check "a".is(ANY[thats_not.empty?])
-  end
+    describe "two levels" do
+      check "hello".is(ANYTHING[thats_not.reverse == "olleh"]).false
+      check "hello".is(ANYTHING[thats_not.reverse == "olle"])
+    end
 
-  describe "two levels" do
-    check "hello".is(ANYTHING[thats_not.reverse == "olleh"]).false
-    check "hello".is(ANYTHING[thats_not.reverse == "olle"])
-  end
+    describe "four levels" do
+      check "hello".is(ANY[thats_not.upcase.partition("E")[0] == "H"]).false
+      check "hello".is(ANY[thats_not.upcase.partition("E")[1] == "E"]).false
+      check "hello".is(ANY[thats_not.upcase.partition("E")[2] == "LLO"]).false
+      check "hello".is(ANY[thats_not.upcase.partition("E")[1] == "H"])
+      check "hello".is(ANY[thats_not.upcase.partition("E")[0] == "h"])
+      check "hello".is(ANY[thats_not.upcase.partition("L")[0] == "H"])
+      check "hello".is(ANY[thats_not.upcase.partition("e")[0] == "H"])
+    end
 
-  describe "four levels" do
-    check "hello".is(ANY[thats_not.upcase.partition("E")[0] == "H"]).false
-    check "hello".is(ANY[thats_not.upcase.partition("E")[1] == "E"]).false
-    check "hello".is(ANY[thats_not.upcase.partition("E")[2] == "LLO"]).false
-    check "hello".is(ANY[thats_not.upcase.partition("E")[1] == "H"])
-    check "hello".is(ANY[thats_not.upcase.partition("E")[0] == "h"])
-    check "hello".is(ANY[thats_not.upcase.partition("L")[0] == "H"])
-    check "hello".is(ANY[thats_not.upcase.partition("e")[0] == "H"])
-  end
+    describe "files" do
+      check { not "#{S[String, thats_not.start_with?(".")]}".filename_in(".").map{S}.include? ".gitignore" }
+      check {     "#{S[String, thats_not.start_with?(".")]}". dirname_in(".").map{S}.include? "lib" }
+    end
 
-  describe "files" do
-    check { not "#{S[String, thats_not.start_with?(".")]}".filename_in(".").map{S}.include? ".gitignore" }
-    check {     "#{S[String, thats_not.start_with?(".")]}". dirname_in(".").map{S}.include? "lib" }
   end
-
 end

data/spec/rubylog/dsl/array_splat_spec.rb

@@ -1,15 +1,17 @@
 require "spec_helper"
 
-describe Rubylog::DSL::ArraySplat, :rubylog=>true do
-  describe "#inspect" do
-    [*A].inspect.should == "[*A]"
-  end
+module RubylogSpec
+  describe Rubylog::DSL::ArraySplat, :rubylog=>true do
+    describe "#inspect" do
+      [*A].inspect.should == "[*A]"
+    end
 
-  specify "#==" do
-    [*A].should == [*A]
-  end
+    specify "#==" do
+      [*A].should == [*A]
+    end
 
-  specify "#eql?" do
-    [*A].should eql [*A]
+    specify "#eql?" do
+      [*A].should eql [*A]
+    end
   end
 end

data/spec/rubylog/dsl/indicators_spec.rb

@@ -1,26 +1,28 @@
 require "spec_helper" 
 
-describe Rubylog::DSL::Indicators do
-  describe "#humanize_indicator" do
-    specify { Rubylog::DSL::Indicators.humanize_indicator([:fail,0]).should == ":fail" }
-    specify { Rubylog::DSL::Indicators.humanize_indicator([:false,1]).should == ".false" }
-    specify { Rubylog::DSL::Indicators.humanize_indicator([:and,2]).should == ".and()" }
-    specify { Rubylog::DSL::Indicators.humanize_indicator([:splits,3]).should == ".splits(,)" }
-    specify { Rubylog::DSL::Indicators.humanize_indicator([:is,4]).should == ".is(,,)" }
-  end
+module RubylogSpec
+  describe Rubylog::DSL::Indicators do
+    describe "#humanize_indicator" do
+      specify { Rubylog::DSL::Indicators.humanize_indicator([:fail,0]).should == ":fail" }
+      specify { Rubylog::DSL::Indicators.humanize_indicator([:false,1]).should == ".false" }
+      specify { Rubylog::DSL::Indicators.humanize_indicator([:and,2]).should == ".and()" }
+      specify { Rubylog::DSL::Indicators.humanize_indicator([:splits,3]).should == ".splits(,)" }
+      specify { Rubylog::DSL::Indicators.humanize_indicator([:is,4]).should == ".is(,,)" }
+    end
 
-  describe "#unhumanize_indicator" do
-    specify { Rubylog::DSL::Indicators.unhumanize_indicator(":fail" ).should == [:fail,0] }
-    specify { Rubylog::DSL::Indicators.unhumanize_indicator(".false" ).should == [:false,1] }
-    specify { Rubylog::DSL::Indicators.unhumanize_indicator(".and()" ).should == [:and,2] }
-    specify { Rubylog::DSL::Indicators.unhumanize_indicator(".splits(,)" ).should == [:splits,3] }
-    specify { Rubylog::DSL::Indicators.unhumanize_indicator(".is(,,)" ).should == [:is,4] }
+    describe "#unhumanize_indicator" do
+      specify { Rubylog::DSL::Indicators.unhumanize_indicator(":fail" ).should == [:fail,0] }
+      specify { Rubylog::DSL::Indicators.unhumanize_indicator(".false" ).should == [:false,1] }
+      specify { Rubylog::DSL::Indicators.unhumanize_indicator(".and()" ).should == [:and,2] }
+      specify { Rubylog::DSL::Indicators.unhumanize_indicator(".splits(,)" ).should == [:splits,3] }
+      specify { Rubylog::DSL::Indicators.unhumanize_indicator(".is(,,)" ).should == [:is,4] }
 
-    describe "with comment variables" do
-      specify { Rubylog::DSL::Indicators.unhumanize_indicator("Predicate.false" ).should == [:false,1] }
-      specify { Rubylog::DSL::Indicators.unhumanize_indicator("a.and(b)" ).should == [:and,2] }
-      specify { Rubylog::DSL::Indicators.unhumanize_indicator("LIST.splits(HEAD,TAIL)" ).should == [:splits,3] }
-      specify { Rubylog::DSL::Indicators.unhumanize_indicator("C.is(A,OP,B)" ).should == [:is,4] }
+      describe "with comment variables" do
+        specify { Rubylog::DSL::Indicators.unhumanize_indicator("Predicate.false" ).should == [:false,1] }
+        specify { Rubylog::DSL::Indicators.unhumanize_indicator("a.and(b)" ).should == [:and,2] }
+        specify { Rubylog::DSL::Indicators.unhumanize_indicator("LIST.splits(HEAD,TAIL)" ).should == [:splits,3] }
+        specify { Rubylog::DSL::Indicators.unhumanize_indicator("C.is(A,OP,B)" ).should == [:is,4] }
+      end
     end
-  end
-end 
+  end 
+end

data/spec/rubylog/dsl/primitives_spec.rb

@@ -1,43 +1,45 @@
 require "spec_helper"
 
-describe Rubylog::DSL::Primitives, :rubylog=>true do
-  describe "#primitives" do
-    before do
-      String.instance_methods.should_not include :looong
-    end
+module RubylogSpec
+  describe Rubylog::DSL::Primitives, :rubylog=>true do
+    describe "#primitives" do
+      before do
+        String.instance_methods.should_not include :looong
+      end
 
-    it "defines functors on default subject" do
-      self.default_subject = String
-      class << primitives
-        def looong s
+      it "defines functors on default subject" do
+        self.default_subject = String
+        class << primitives
+          def looong s
+          end
         end
+        String.instance_methods.should include :looong
+        String.instance_methods.should include :looong!
+        String.instance_methods.should include :looong?
       end
-      String.instance_methods.should include :looong
-      String.instance_methods.should include :looong!
-      String.instance_methods.should include :looong?
     end
-  end
 
-  describe "#primitives_for" do
-    before do
-      Integer.instance_methods.should_not include :large
-    end
+    describe "#primitives_for" do
+      before do
+        Integer.instance_methods.should_not include :large
+      end
 
-    it "defines functors on the given subject" do
-      class << primitives_for(Integer)
-        def large s
+      it "defines functors on the given subject" do
+        class << primitives_for(Integer)
+          def large s
+          end
         end
+        Integer.instance_methods.should include :large
+        Integer.instance_methods.should include :large!
+        Integer.instance_methods.should include :large?
       end
-      Integer.instance_methods.should include :large
-      Integer.instance_methods.should include :large!
-      Integer.instance_methods.should include :large?
     end
-  end
 
-  describe "Primitives#inspect" do
-    specify do
-      primitives_for(Integer).inspect.should =~ /\Aprimitives_for\(.*\)\z/
+    describe "Primitives#inspect" do
+      specify do
+        primitives_for(Integer).inspect.should =~ /\Aprimitives_for\(.*\)\z/
+      end
     end
-  end
 
+  end
 end

data/spec/rubylog/errors_spec.rb

@@ -1,18 +1,20 @@
 require 'spec_helper'
 
-describe "Rubylog errors", :rubylog=>true do
+module RubylogSpec
+  describe "Rubylog errors", :rubylog=>true do
 
-  describe "syntax error" do
-    predicate_for String, ".happy"
+    describe "syntax error" do
+      predicate_for String, ".happy"
 
-    specify { proc{ "John".happy.if }.should raise_error Rubylog::SyntaxError }
-    specify { proc{ "John".happy.if! }.should raise_error Rubylog::SyntaxError }
-    specify { proc{ "John".happy.unless }.should raise_error Rubylog::SyntaxError }
-  end
+      specify { proc{ "John".happy.if }.should raise_error Rubylog::SyntaxError }
+      specify { proc{ "John".happy.if! }.should raise_error Rubylog::SyntaxError }
+      specify { proc{ "John".happy.unless }.should raise_error Rubylog::SyntaxError }
+    end
 
-  describe Rubylog::InstantiationError do
-    specify { proc { A.true? }.should raise_error(Rubylog::InstantiationError, "Instantiation error in A") }
-    specify { proc { A.sum_of(B,1).true? }.should raise_error(Rubylog::InstantiationError, "Instantiation error in A.sum_of(B, 1)") }
-  end
+    describe Rubylog::InstantiationError do
+      specify { proc { A.true? }.should raise_error(Rubylog::InstantiationError, "Instantiation error in A") }
+      specify { proc { A.sum_of(B,1).true? }.should raise_error(Rubylog::InstantiationError, "Instantiation error in A.sum_of(B, 1)") }
+    end
 
+  end
 end

data/spec/rubylog/interfaces/term_spec.rb

@@ -1,83 +1,85 @@
 require 'spec_helper'
 
-describe "unification", :rubylog=>true do
-  predicate_for Symbol, ".likes"
+module RubylogSpec
+  describe "unification", :rubylog=>true do
+    predicate_for Symbol, ".likes"
 
-  it "works for variables" do
-    result = false
-    A.rubylog_unify(12) { result = true }
-    result.should == true
-  end
-  it "works for used classes" do
-    result = false
-    :john.rubylog_unify(A) { result = true }
-    result.should == true
-  end
-  it "works for constants" do
-    result = false
-    :john.rubylog_unify(:john) { result = true }
-    result.should == true
-  end
-  it "fails for different constants" do
-    result = false
-    :john.rubylog_unify(:mary) { result = true }
-    result.should == false
-  end
-  it "works on structures" do
-    result = false
-    (:john.likes :beer).rubylog_unify(A.likes B) { result = true }
-    result.should == true
-  end
-  it "works on structures with equal values" do
-    result = false
-    (:john.likes :beer).rubylog_unify(:john.likes :beer) { result = true }
-    result.should == true
-  end
-  it "works on structures with different values" do
-    result = false
-    (:john.likes :beer).rubylog_unify(:john.likes :milk) { result = true }
-    result.should == false
-  end
-  it "works on structures with variables and equal values" do
-    result = false
-    (:john.likes :beer).rubylog_unify(X.likes :beer) { result = true }
-    result.should == true
-  end
-  it "works on structures with variables and equal values #2" do
-    result = false
-    (:john.likes :beer).rubylog_unify(:john.likes DRINK) { result = true }
-    result.should == true
-  end
-  it "works on structures with variables and different values" do
-    result = false
-    (:john.likes :beer).rubylog_unify(X.likes :milk) { result = true }
-    result.should == false
-  end
-  it "works on structures with variables and different values #2" do
-    result = false
-    (:john.likes :beer).rubylog_unify(:jane.likes D) { result = true }
-    result.should == false
-  end
+    it "works for variables" do
+      result = false
+      A.rubylog_unify(12) { result = true }
+      result.should == true
+    end
+    it "works for used classes" do
+      result = false
+      :john.rubylog_unify(A) { result = true }
+      result.should == true
+    end
+    it "works for constants" do
+      result = false
+      :john.rubylog_unify(:john) { result = true }
+      result.should == true
+    end
+    it "fails for different constants" do
+      result = false
+      :john.rubylog_unify(:mary) { result = true }
+      result.should == false
+    end
+    it "works on structures" do
+      result = false
+      (:john.likes :beer).rubylog_unify(A.likes B) { result = true }
+      result.should == true
+    end
+    it "works on structures with equal values" do
+      result = false
+      (:john.likes :beer).rubylog_unify(:john.likes :beer) { result = true }
+      result.should == true
+    end
+    it "works on structures with different values" do
+      result = false
+      (:john.likes :beer).rubylog_unify(:john.likes :milk) { result = true }
+      result.should == false
+    end
+    it "works on structures with variables and equal values" do
+      result = false
+      (:john.likes :beer).rubylog_unify(X.likes :beer) { result = true }
+      result.should == true
+    end
+    it "works on structures with variables and equal values #2" do
+      result = false
+      (:john.likes :beer).rubylog_unify(:john.likes DRINK) { result = true }
+      result.should == true
+    end
+    it "works on structures with variables and different values" do
+      result = false
+      (:john.likes :beer).rubylog_unify(X.likes :milk) { result = true }
+      result.should == false
+    end
+    it "works on structures with variables and different values #2" do
+      result = false
+      (:john.likes :beer).rubylog_unify(:jane.likes D) { result = true }
+      result.should == false
+    end
 
-  it "works on structures with repeated variables #1" do
-    result = false
-    (A.likes A).rubylog_match_variables.rubylog_unify(:john.likes :jane) { result = true }
-    result.should == false
-    (A.likes A).rubylog_match_variables.rubylog_unify(:john.likes :john) { result = true }
-    result.should == true
-  end
-  it "works on structures with repeated variables #1" do
-    result = false
-    (:john.likes :jane).rubylog_unify(A.likes(A).rubylog_match_variables) { result = true }
-    result.should == false
-    (:john.likes :john).rubylog_unify(A.likes(A).rubylog_match_variables) { result = true }
-    result.should == true
-  end
+    it "works on structures with repeated variables #1" do
+      result = false
+      (A.likes A).rubylog_match_variables.rubylog_unify(:john.likes :jane) { result = true }
+      result.should == false
+      (A.likes A).rubylog_match_variables.rubylog_unify(:john.likes :john) { result = true }
+      result.should == true
+    end
+    it "works on structures with repeated variables #1" do
+      result = false
+      (:john.likes :jane).rubylog_unify(A.likes(A).rubylog_match_variables) { result = true }
+      result.should == false
+      (:john.likes :john).rubylog_unify(A.likes(A).rubylog_match_variables) { result = true }
+      result.should == true
+    end
 
-  it "works for second-order variables" do
-    result = false
-    (:john.likes :beer).rubylog_unify(A) { result = true }
-    result.should == true
-  end
+    it "works for second-order variables" do
+      result = false
+      (:john.likes :beer).rubylog_unify(A) { result = true }
+      result.should == true
+    end
 
+  end
 end