rubylog 1.0.0 → 2.0pre1

data/spec/rubylog/context_modules/thats_spec.rb

@@ -0,0 +1,94 @@
+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
+
+  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 "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" }
+    check { "#{S[/\A(.*)\.rb/]}".filename_in("lib").map{S} == ["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 "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
+
+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 "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 "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

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

data/spec/rubylog/dsl/primitives_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+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
+        end
+      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
+
+    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
+  end
+
+  describe "Primitives#inspect" do
+    specify do
+      primitives_for(Integer).inspect.should =~ /\Aprimitives_for\(.*\)\z/
+    end
+  end
+
+end

data/spec/rubylog/errors_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe "Rubylog errors", :rubylog=>true do
+
+  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
+
+  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

data/spec/{unification_spec.rb → rubylog/interfaces/term_spec.rb}

@@ -1,9 +1,8 @@
-theory "Uni" do
-  subject Symbol
-  functor :likes
-end
+require 'spec_helper'
+
+describe "unification", :rubylog=>true do
+  predicate_for Symbol, ".likes"
 
-describe "unification" do
   it "works for variables" do
     result = false
     A.rubylog_unify(12) { result = true }
@@ -62,16 +61,16 @@ describe "unification" do
 
   it "works on clauses with repeated variables #1" do
     result = false
-    (A.likes A).rubylog_compile_variables.rubylog_unify(:john.likes :jane) { result = true }
+    (A.likes A).rubylog_match_variables.rubylog_unify(:john.likes :jane) { result = true }
     result.should == false
-    (A.likes A).rubylog_compile_variables.rubylog_unify(:john.likes :john) { result = true }
+    (A.likes A).rubylog_match_variables.rubylog_unify(:john.likes :john) { result = true }
     result.should == true
   end
   it "works on clauses with repeated variables #1" do
     result = false
-    (:john.likes :jane).rubylog_unify(A.likes(A).rubylog_compile_variables) { result = true }
+    (: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_compile_variables) { result = true }
+    (:john.likes :john).rubylog_unify(A.likes(A).rubylog_match_variables) { result = true }
     result.should == true
   end
 

data/spec/rubylog/mixins/array_spec.rb

@@ -0,0 +1,80 @@
+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
+
+    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 "unifies empty arrays" do
+      can_unify [], []
+    end
+
+    it "unifies empty array with splat" do
+      a = A
+      can_unify [], [*a] do
+        a.value.should == []
+      end
+    end
+
+    it "unifies two splats" do
+      a = A
+      b = B
+      can_unify [*a], [*b] do
+        b.value.should equal a
+      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]
+      end
+    end
+
+    it "unifies a splat with empty array" do
+      a = A
+      can_unify [*a], [] do
+        a.value.should eql []
+      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 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
+
+
+  end
+
+  describe "#rubylog_deep_dereference" do
+    it "does keeps unbound splats" do
+      [*A].rubylog_deep_dereference.should eql [*A]
+    end
+  end
+
+end

data/spec/rubylog/mixins/composite_term_spec.rb

@@ -0,0 +1,66 @@
+require "spec_helper"
+
+describe Rubylog::CompoundTerm, :rubylog=>true do
+  predicate_for Symbol, ".likes()"
+
+  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 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 "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 "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

data/spec/rubylog/mixins/proc_spec.rb

@@ -0,0 +1,59 @@
+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
+    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

data/spec/rubylog/mixins/string_spec.rb

@@ -0,0 +1,48 @@
+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
+
+  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

data/spec/rubylog/mixins/symbol_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Symbol, :rubylog=>true do
+  it "can be asserted" do
+    predicate ":good"
+    :good.if { true }
+    true?(:good).should be_true
+  end
+end

data/spec/{clause_spec.rb → rubylog/structure_spec.rb}

@@ -1,9 +1,9 @@
-require 'rubylog'
+require 'spec_helper'
 
-theory "Vars" do
-end
+describe Rubylog::Structure, :rubylog=>true do
+
+  predicate_for Symbol, ".is_happy .likes()"
 
-describe "clauses" do
   it "can be created" do
     (:john.is_happy).should be_kind_of Rubylog::Term
     (:john.likes :beer).should be_kind_of Rubylog::Term
@@ -11,19 +11,16 @@ describe "clauses" do
     (:john.likes Drink).should be_kind_of Rubylog::Term
     (:john.likes :drinking.in :bar).should be_kind_of Rubylog::Term
   end
+
   it "forbids non-declared names" do
     lambda { :john.something_else }.should raise_error(NoMethodError)
   end
-  it "also work with operators" do
-    (:is_happy%1).should be_kind_of Rubylog::Term
-    (A%B).should be_kind_of Rubylog::Term
-  end
+
   it "can be asked for their functor" do
     (:john.is_happy).functor.should == :is_happy
-    (:is_happy%1).functor.should == :%
-    (A%1).functor.should == :%
     (:john.likes :drinking.in :bar).functor.should == :likes
   end
+
   it "can be indexed" do
     (:john.is_happy)[0].should == :john
     (:john.likes :beer)[0].should == :john
@@ -32,6 +29,7 @@ describe "clauses" do
     (:john.likes(:cold, :beer))[1..2].should == [:cold,:beer]
     (:john.likes :drinking.in :bar)[1].should == (:drinking.in :bar)
   end
+
   it "can be asked for their args" do
     (:john.is_happy).args.should == [:john]
     (:john.likes :beer).args.should == [:john, :beer]
@@ -72,11 +70,14 @@ describe "clauses" do
     (:john.likes :drinking,:beer).arity.should == 3
     (:john.likes :drinking.in :bar).arity.should == 2
   end
-  it "can tell their descriptor" do
-    (:john.is_happy).desc.should == [:is_happy,1]
-    (:john.likes :beer).desc.should == [:likes,2]
-    (:john.likes :drinking,:beer).desc.should == [:likes,3]
-    (:john.likes :drinking.in :bar).desc.should == [:likes,2]
+
+  it "can tell their indicator" do
+    (:john.is_happy).indicator.should == [:is_happy,1]
+    (:john.likes :beer).indicator.should == [:likes,2]
+    (:john.likes :drinking,:beer).indicator.should == [:likes,3]
+    (:john.likes :drinking.in :bar).indicator.should == [:likes,2]
   end
+
+
 end
 

data/spec/rubylog/term_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+
+describe "unification", :rubylog=>true do
+  it "uses eql?" do
+    check 5.is_not 5.0
+  end
+end

data/spec/rubylog/tracing_spec.input

@@ -0,0 +1,27 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

data/spec/rubylog/tracing_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+
+describe Rubylog::Tracing, :rubylog=>true do
+  before do
+    @old_argv = ARGV.dup
+    ARGV.replace ["spec/rubylog/tracing_spec.input"]
+    @old_stdout = $stdout
+    $stdout = @output = StringIO.new
+  end
+
+  after do
+    Rubylog.trace?.should == false
+    $stdout = @old_stdout
+    ARGV.replace @old_argv
+  end
+
+  it "can be called with true/false" do
+    Rubylog.trace true
+    1.is(A).solve
+    Rubylog.trace false
+    @output.string.should include "1.is(A).prove()"
+  end
+
+  it "can be called without true" do
+    Rubylog.trace 
+    1.is(A).solve
+    Rubylog.trace false
+    @output.string.should include "1.is(A).prove()"
+  end
+
+  it "can be called with a block" do
+    Rubylog.trace do
+      1.is(A).solve
+    end
+    @output.string.should include "1.is(A).prove()"
+  end
+
+  it "traces unifications" do
+    Rubylog.trace do
+      1.is(A).solve
+    end
+    @output.string.should include "A.bind_to(1)"
+  end
+end