rubylog 1.0.0 → 2.0pre1

data/spec/rubylog/builtins/logic_spec.rb

@@ -0,0 +1,340 @@
+require 'spec_helper'
+
+describe "logic builtins", :rubylog => true do
+  before do
+    predicate_for Symbol, ".likes() .happy"
+  end
+
+  specify "true" do
+    :john.happy.if :true
+    :john.should be_happy
+  end
+
+  specify "fail" do
+    :john.happy.if :fail
+    :john.should_not be_happy
+  end
+
+  describe "false" do
+    specify do
+      :john.happy.if :true.false
+      :john.should_not be_happy
+    end
+
+    specify do
+      :john.happy.if :fail.false
+      :john.should be_happy
+    end
+  end
+
+  describe "and" do
+    it "works 1" do
+      :john.happy.if :fail.and :true
+      :john.should_not be_happy
+    end
+
+    it "works 2" do
+      :john.happy.if :true.and :fail
+      :john.should_not be_happy
+    end
+
+    it "works 3" do
+      :john.happy.if :fail.and :fail
+      :john.should_not be_happy
+    end
+
+    it "works 4" do
+      :john.happy.if :true.and :true
+      :john.should be_happy
+    end
+  end
+
+
+  describe "or" do
+    it "works 1" do
+      :john.happy.if :fail.or :true
+      :john.should be_happy
+    end
+
+    it "works 2" do
+      :john.happy.if :true.or :fail
+      :john.should be_happy
+    end
+
+    it "works 3" do
+      :john.happy.if :fail.or :fail
+      :john.should_not be_happy
+    end
+
+    it "works 4" do
+      :john.happy.if :true.or :true
+      :john.should be_happy
+    end
+  end
+
+
+  describe "branch or" do
+    it "works 1" do
+      :john.happy.if :fail
+      :john.happy.if :true
+      :john.should be_happy
+    end
+
+    it "works 2" do
+      :john.happy.if :true
+      :john.happy.if :fail
+      :john.should be_happy
+    end
+
+    it "works 3" do
+      :john.happy.if :fail
+      :john.happy.if :fail
+      :john.should_not be_happy
+    end
+
+    it "works 4" do
+      :john.happy.if :true
+      :john.happy.if :true
+      :john.should be_happy
+    end
+  end
+
+  describe "iff" do
+    it "works 1" do
+      :john.happy.if :fail.iff :true
+      :john.should_not be_happy
+    end
+
+    it "works 2" do
+      :john.happy.if :true.iff :fail
+      :john.should_not be_happy
+    end
+
+    it "works 3" do
+      :john.happy.if :fail.iff :fail
+      :john.should be_happy
+    end
+
+    it "works 4" do
+      :john.happy.if :true.iff :true
+      :john.should be_happy
+    end
+  end
+
+  describe "cut" do
+    it "works with branch or" do
+      :john.happy.if :true.and :cut!.and :fail
+      :john.happy.if :true
+      :john.should_not be_happy
+    end
+    it "works with branch or (control)" do
+      :john.happy.if :true.and :fail
+      :john.happy.if :true
+      :john.should be_happy
+    end
+
+    it "works with or" do
+      :john.happy.if((:true.and :cut!.and :fail).or :true)
+      :john.should_not be_happy
+    end
+
+    it "works with or (control)" do
+      :john.happy.if((:true.and :fail).or :true)
+      :john.should be_happy
+    end
+
+    it "returns true with branch or" do
+      :john.happy.if :true.and :cut!.and :true
+      :john.happy.if :true
+      :john.should be_happy
+    end
+    it "returns true with branch or (control)" do
+      :john.happy.if :true.and :true
+      :john.happy.if :true
+      :john.should be_happy
+    end
+
+    it "returns true with or" do
+      :john.happy.if((:true.and :cut!.and :true).or :true)
+      :john.should be_happy
+    end
+
+    it "returns true with or (control)" do
+      :john.happy.if((:true.and :true).or :true)
+      :john.should be_happy
+    end
+  end
+
+  describe "all,any,one,none,every" do
+    before do
+      :john.likes! :water
+      :john.likes! :beer
+
+      :jane.likes! :water
+      :jane.likes! :milk
+      :jane.likes! :beer
+
+      :jeff.likes! :water
+      :jeff.likes! :absinth
+
+      :todd.likes! :milk
+
+      @predicates = [:all, :any, :one, :none]
+      @names = :john, :jane, :jeff, :todd
+      @good =
+        [
+          [[1,1,0,0], [0,1,0,0], [0,0,1,0], [0,1,0,1]], # all
+          [[1,1,1,0], [1,1,1,1], [1,1,1,0], [0,1,0,1]], # any
+          [[0,0,1,0], [0,0,1,1], [1,1,0,0], [0,1,0,1]], # one
+          [[0,0,0,1], [0,0,0,0], [0,0,0,1], [1,0,1,0]]  # none
+      ]
+    end
+
+    it "work" do
+      @predicates.map{|p| @names.map{|n| @names.map{|m| 
+        (n.likes(K).send p, m.likes(K)).true? ? 1 : 0
+      }}}.should == @good
+    end
+
+    it "mimic well enumerators' predicates" do
+      @predicates.map{|p| @names.map{|n| @names.map{|m|
+        n.likes(K).map{K}.send(:"#{p}?"){|x| m.likes?(x) } ? 1 : 0
+      }}}.should == @good
+    end
+
+
+
+    specify "all works" do
+      (:john.likes(X).all(:john.likes(X))).true?.should be_true
+      (:john.likes(X).all(:jane.likes(X))).true?.should be_true
+      (:john.likes(X).all(:jeff.likes(X))).true?.should_not be_true
+      (:john.likes(X).all(:todd.likes(X))).true?.should_not be_true
+
+      (:jane.likes(X).all(:john.likes(X))).true?.should_not be_true
+      (:jane.likes(X).all(:jane.likes(X))).true?.should be_true
+      (:jane.likes(X).all(:jeff.likes(X))).true?.should_not be_true
+      (:jane.likes(X).all(:todd.likes(X))).true?.should_not be_true
+
+      (:jeff.likes(X).all(:john.likes(X))).true?.should_not be_true
+      (:jeff.likes(X).all(:jane.likes(X))).true?.should_not be_true
+      (:jeff.likes(X).all(:jeff.likes(X))).true?.should be_true
+      (:jeff.likes(X).all(:todd.likes(X))).true?.should_not be_true
+
+      (:todd.likes(X).all(:john.likes(X))).true?.should_not be_true
+      (:todd.likes(X).all(:jane.likes(X))).true?.should be_true
+      (:todd.likes(X).all(:jeff.likes(X))).true?.should_not be_true
+      (:todd.likes(X).all(:todd.likes(X))).true?.should be_true
+    end
+
+    specify "all works with procs" do
+      (:john.likes(X).all{:john.likes?(X)}).true?.should be_true
+      (:john.likes(X).all{:jane.likes?(X)}).true?.should be_true
+      (:john.likes(X).all{:jeff.likes?(X)}).true?.should_not be_true
+      (:john.likes(X).all{:todd.likes?(X)}).true?.should_not be_true
+
+      (:jane.likes(X).all{:john.likes?(X)}).true?.should_not be_true
+      (:jane.likes(X).all{:jane.likes?(X)}).true?.should be_true
+      (:jane.likes(X).all{:jeff.likes?(X)}).true?.should_not be_true
+      (:jane.likes(X).all{:todd.likes?(X)}).true?.should_not be_true
+
+      (:jeff.likes(X).all{:john.likes?(X)}).true?.should_not be_true
+      (:jeff.likes(X).all{:jane.likes?(X)}).true?.should_not be_true
+      (:jeff.likes(X).all{:jeff.likes?(X)}).true?.should be_true
+      (:jeff.likes(X).all{:todd.likes?(X)}).true?.should_not be_true
+
+      (:todd.likes(X).all{:john.likes?(X)}).true?.should_not be_true
+      (:todd.likes(X).all{:jane.likes?(X)}).true?.should be_true
+      (:todd.likes(X).all{:jeff.likes?(X)}).true?.should_not be_true
+      (:todd.likes(X).all{:todd.likes?(X)}).true?.should be_true
+    end
+
+    it "can be called with global functor syntax" do
+      all(:john.likes(X), :jane.likes(X)).true?.should be_true
+      all(:jane.likes(X), :john.likes(X)).true?.should_not be_true
+      any(:jane.likes(X), :todd.likes(X)).true?.should be_true
+      any(:john.likes(X), :todd.likes(X)).true?.should_not be_true
+    end
+
+    it "one, any, none can be called unarily" do
+      one(:john.likes(X)).true?.should_not be_true
+      one(:jane.likes(X)).true?.should_not be_true
+      one(:jeff.likes(X)).true?.should_not be_true
+      one(:todd.likes(X)).true?.should be_true
+      one(:jim.likes(X)).true?.should_not be_true
+
+      any(:john.likes(X)).true?.should be_true
+      any(:jane.likes(X)).true?.should be_true
+      any(:jeff.likes(X)).true?.should be_true
+      any(:todd.likes(X)).true?.should be_true
+      any(:jim.likes(X)).true?.should_not be_true
+
+      none(:john.likes(X)).true?.should_not be_true
+      none(:jane.likes(X)).true?.should_not be_true
+      none(:jeff.likes(X)).true?.should_not be_true
+      none(:todd.likes(X)).true?.should_not be_true
+      none(:jim.likes(X)).true?.should be_true
+    end
+
+    it "does not hijack variables" do
+      A.is(X.is(5)).and(A.all{X<10}).true?.should == true
+    end
+
+    describe "every" do
+      specify "works like all" do
+        every(:john.likes(X),:john.likes(X)).true?.should be_true
+        every(:john.likes(X),:jane.likes(X)).true?.should be_true
+        every(:john.likes(X),:jeff.likes(X)).true?.should_not be_true
+        every(:john.likes(X),:todd.likes(X)).true?.should_not be_true
+
+        every(:jane.likes(X),:john.likes(X)).true?.should_not be_true
+        every(:jane.likes(X),:jane.likes(X)).true?.should be_true
+        every(:jane.likes(X),:jeff.likes(X)).true?.should_not be_true
+        every(:jane.likes(X),:todd.likes(X)).true?.should_not be_true
+
+        every(:jeff.likes(X),:john.likes(X)).true?.should_not be_true
+        every(:jeff.likes(X),:jane.likes(X)).true?.should_not be_true
+        every(:jeff.likes(X),:jeff.likes(X)).true?.should be_true
+        every(:jeff.likes(X),:todd.likes(X)).true?.should_not be_true
+
+        every(:todd.likes(X),:john.likes(X)).true?.should_not be_true
+        every(:todd.likes(X),:jane.likes(X)).true?.should be_true
+        every(:todd.likes(X),:jeff.likes(X)).true?.should_not be_true
+        every(:todd.likes(X),:todd.likes(X)).true?.should be_true
+      end
+
+      specify "works like all with procs" do
+        every(:john.likes(X)){:john.likes?(X)}.true?.should be_true
+        every(:john.likes(X)){:jane.likes?(X)}.true?.should be_true
+        every(:john.likes(X)){:jeff.likes?(X)}.true?.should_not be_true
+        every(:john.likes(X)){:todd.likes?(X)}.true?.should_not be_true
+
+        every(:jane.likes(X)){:john.likes?(X)}.true?.should_not be_true
+        every(:jane.likes(X)){:jane.likes?(X)}.true?.should be_true
+        every(:jane.likes(X)){:jeff.likes?(X)}.true?.should_not be_true
+        every(:jane.likes(X)){:todd.likes?(X)}.true?.should_not be_true
+
+        every(:jeff.likes(X)){:john.likes?(X)}.true?.should_not be_true
+        every(:jeff.likes(X)){:jane.likes?(X)}.true?.should_not be_true
+        every(:jeff.likes(X)){:jeff.likes?(X)}.true?.should be_true
+        every(:jeff.likes(X)){:todd.likes?(X)}.true?.should_not be_true
+
+        every(:todd.likes(X)){:john.likes?(X)}.true?.should_not be_true
+        every(:todd.likes(X)){:jane.likes?(X)}.true?.should be_true
+        every(:todd.likes(X)){:jeff.likes?(X)}.true?.should_not be_true
+        every(:todd.likes(X)){:todd.likes?(X)}.true?.should be_true
+      end
+
+
+      specify "can be used for assumptions" do
+        predicate_for Symbol, ".good"
+        # assumptions reverse the order
+        every(:john.likes(X), X.good.assumed).and(Y.good).map{Y}.should == [:beer, :water]
+      end
+
+    end
+
+
+
+  end
+
+end

data/spec/rubylog/builtins/reflection_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+require "rubylog/builtins/reflection"
+
+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")] }
+    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)] }
+    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]]] }
+    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")] }
+    end
+  end
+
+
+end

data/spec/rubylog/builtins/term_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe "Term builtins", :rubylog => true do
+  before do
+    predicate_for Symbol, ".likes"
+  end
+
+  describe "in" do
+    before do
+      :john.likes! :beer
+      :jane.likes! :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 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 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 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 with clauses" do
+      (A.likes(B).and B.in{:john.likes(X).map{X}}).map{[A,B]}.should == [[:john, :beer]]
+    end
+
+    it "checks instatiation" do
+      expect { 5.in(B).map{B} }.to raise_error Rubylog::InstantiationError
+    end
+
+  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
+    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
+
+  end
+
+end

data/spec/rubylog/context_modules/demonstration_spec.rb

@@ -0,0 +1,132 @@
+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
+
+  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 "work with variables" do
+    :john.likes?(X).should be_false
+    :john.likes! :water
+    :john.likes?(X).should be_true
+  end
+
+  it "yield all solutions" do
+    :john.likes! :beer
+    :john.likes! :milk
+
+    k=[]
+    (:john.likes X).each{k << X}
+    k.should == [:beer, :milk]
+  end
+
+  it "yield all solutions with solve" do
+    :john.likes! :beer
+    :john.likes! :milk
+
+    k=[]
+    (:john.likes X).solve{k << X}
+    k.should == [:beer, :milk]
+  end
+
+  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 Y).solve{k << [X,Y]}
+    k.should == [[:john, :beer], [:jane, :milk], [:jane, :water]]
+  end
+
+  it "ignore don't-care variables" do
+    :john.likes! :beer
+
+    k=[]
+    ANYONE.likes(X).each{k << [ANYONE,X]}
+    k.should == [[ANYONE, :beer]]
+
+    k=[]
+    X.likes(ANYTHING).each{k << [X,ANYTHING]}
+    k.should == [[:john, ANYTHING]]
+  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 "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 "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
+
+  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

data/spec/rubylog/context_modules/predicates_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper" 
+
+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 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
+    end
+  end
+
+  describe "#humanize_indicator" do
+    specify { humanize_indicator([:fail,0]).should == ":fail" }
+    specify { humanize_indicator([:false,1]).should == ".false" }
+    specify { humanize_indicator([:and,2]).should == ".and()" }
+    specify { humanize_indicator([:splits,3]).should == ".splits(,)" }
+    specify { humanize_indicator([:is,4]).should == ".is(,,)" }
+  end
+
+  describe "#unhumanize_indicator" do
+    specify { unhumanize_indicator(":fail" ).should == [:fail,0] }
+    specify { unhumanize_indicator(".false" ).should == [:false,1] }
+    specify { unhumanize_indicator(".and()" ).should == [:and,2] }
+    specify { unhumanize_indicator(".splits(,)" ).should == [:splits,3] }
+    specify { unhumanize_indicator(".is(,,)" ).should == [:is,4] }
+
+    describe "with comment variables" do
+      specify { unhumanize_indicator("Predicate.false" ).should == [:false,1] }
+      specify { unhumanize_indicator("a.and(b)" ).should == [:and,2] }
+      specify { unhumanize_indicator("LIST.splits(HEAD,TAIL)" ).should == [:splits,3] }
+      specify { unhumanize_indicator("C.is(A,OP,B)" ).should == [:is,4] }
+    end
+  end
+end