rubylog 0.0.1 → 1.0.0

data/spec/builtins/then_spec.rb

@@ -0,0 +1,27 @@
+
+      describe "then" do
+        it "works 1" do
+          :john.happy.if :fail.then :true
+          :john.should_not be_happy
+        end
+
+        it "works 2" do
+          :john.happy.if :true.then :fail
+          :john.should_not be_happy
+        end
+
+        it "works 3" do
+          :john.happy.if :fail.then :fail
+          :john.should_not be_happy
+        end
+
+        it "works 4" do
+          :john.happy.if :true.then :true
+          :john.should be_happy
+        end
+
+        it "works 5" do
+          :john.happy.if :true.then :true
+          :john.should be_happy
+        end
+      end

data/spec/builtins/true_spec.rb

@@ -0,0 +1,5 @@
+
+      it "true" do
+        :john.happy.if :true
+        :john.should be_happy
+      end

data/spec/clause_spec.rb

@@ -0,0 +1,82 @@
+require 'rubylog'
+
+theory "Vars" do
+end
+
+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
+    (A.likes :beer).should be_kind_of Rubylog::Term
+    (: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
+    (:john.likes :beer)[1].should == :beer
+    (:john.likes(:cold, :beer))[2].should == :beer
+    (: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]
+    (:john.likes(:cold, :beer)).args.should == [:john, :cold, :beer]
+    (:john.likes :drinking.in :bar).args.should == [:john, :drinking.in(:bar)]
+  end
+  it "support ==" do
+    (:john.is_happy).should == (:john.is_happy)
+    (:john.is_happy).should_not be_equal(:john.is_happy)
+    (:john.is_happy).should_not == nil
+    (:john.is_happy).should_not == 9
+    (:john.is_happy).should_not == :john
+    (:john.is_happy).should_not == Rubylog
+    (:john.likes :drinking.in :bar).should == (:john.likes :drinking.in :bar)
+  end
+  it "support eql?" do
+    (:john.is_happy).should be_eql(:john.is_happy)
+    (:john.is_happy).should_not be_eql nil
+    (:john.is_happy).should_not be_eql 9
+    (:john.is_happy).should_not be_eql :john
+    (:john.is_happy).should_not be_eql Rubylog
+    (:john.likes :drinking.in :bar).should be_eql(:john.likes :drinking.in :bar)
+  end
+  it "support hash" do
+    (:john.is_happy).hash.should == (:john.is_happy).hash
+    (:john.likes :drinking.in :bar).hash.should == 
+      (:john.likes :drinking.in :bar).hash
+  end
+  it "support inspect" do
+    (:john.is_happy).inspect.should == ":john.is_happy"
+    (:john.likes :beer).inspect.should == ":john.likes(:beer)"
+    (:john.likes :drinking,:beer).inspect.should == ":john.likes(:drinking, :beer)"
+    (:john.likes :drinking.in :bar).inspect.should == ":john.likes(:drinking.in(:bar))"
+  end
+  it "can tell their arity" do
+    (:john.is_happy).arity.should == 1
+    (:john.likes :beer).arity.should == 2
+    (: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]
+  end
+end
+

data/spec/compilation_spec.rb

@@ -0,0 +1,61 @@
+
+    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_compile_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_compile_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_compile_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_compile_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_compile_variables.rubylog_variables.should == [a, b]
+        (a.likes a1).rubylog_compile_variables.rubylog_variables.should == [a]
+        (a.likes a1.in b).rubylog_compile_variables.rubylog_variables.should == [a, b]
+        (a.likes a1,b,b1,a2,c).rubylog_compile_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_compile_variables.rubylog_variables.should == [b]
+        (a.likes a1).rubylog_compile_variables.rubylog_variables.should == []
+        (a.likes a1.in b).rubylog_compile_variables.
+          rubylog_variables.should == [b]
+        (a.likes a1,b,b1,a2,c).rubylog_compile_variables.
+          rubylog_variables.should == [b, c]
+      end
+
+
+    end

data/spec/custom_classes_spec.rb

@@ -0,0 +1,43 @@
+
+    describe "custom classes" do
+      before do
+        class User
+          rubylog_functor :girl, :boy
+          include Rubylog::DSL::Constants
+
+          attr_reader :name
+          def initialize name
+            @name = name
+          end
+          
+          U.girl.if {|u| u.name =~ /[aeiouh]$/ }
+          U.boy.unless U.girl
+        end
+      end
+
+      it "can have ruby predicates" do
+        john = User.new "John"
+        john.girl?.should be_false
+        john.boy?.should be_true
+        jane = User.new "Jane"
+        jane.girl?.should be_true
+        jane.boy?.should be_false
+      end
+      
+      it "can be used in assertions" do
+        pete = User.new "Pete"
+        pete.boy?.should be_false
+        pete.boy!
+        pete.boy?.should be_true
+
+        Rubylog.theory[:girl][1].discontinuous!
+        janet = User.new "Janet"
+        janet.girl?.should be_false
+        janet.girl!
+        janet.girl?.should be_true
+      end
+
+
+
+
+    end

data/spec/dereference.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe "Dereference" do
+  specify do
+    t = theory do
+      Rubylog::Variable.should === A
+      
+    end
+  end
+end

data/spec/{inriasuite.rb → inriasuite_spec.rb}

@@ -1,20 +1,13 @@
-describe "abolish" do
-
-end
-
 describe "and" do
-  it {
+  specify do
     (X.is(1).and X.var).to_a.should == []
     (X.var.and X.is(1)).to_a.should == [1]
     (:fail.and :call[3]).to_a.should == []
     lambda { (:nofoo[X].and X.call).to_a }.
       should raise_error ExistenceError
     (X.is(:true).and X.call).should == [:true]
-  }
+  end
 end
 
 
-describe "arg" do
-
-end
 

data/spec/queries_spec.rb

@@ -0,0 +1,150 @@
+
+    describe "queries" do
+      it "can be run with true?" do
+        lambda {Rubylog.theory.true?(:john.likes :beer)}.should raise_error(Rubylog::ExistenceError)
+        :john.likes! :beer
+        Rubylog.theory.true?(:john.likes :beer).should be_true
+        Rubylog.theory.true?(:john.likes :milk).should be_false
+      end
+
+      it "can be run with question mark" do
+        lambda {Rubylog.theory.true?(:john.likes :beer)}.should raise_error(Rubylog::ExistenceError)
+        :john.likes! :beer
+        :john.likes?(:beer).should be_true
+      end
+
+      it "can be run with true?" do
+        lambda {Rubylog.theory.true?(:john.likes :beer)}.should raise_error(Rubylog::ExistenceError)
+        :john.likes! :beer
+        (:john.likes(:beer)).true?.should be_true
+      end
+      
+      it "work with variables" do
+        lambda {Rubylog.theory.true?(:john.likes X)}.should raise_error(Rubylog::ExistenceError)
+        :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{|x|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{|x|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{|a,b|k << [a,b]}
+        k.should == [[:john, :beer], [:jane, :milk], [:jane, :water]]
+      end
+
+      it "ignore don't-care variables" do
+        :john.likes! :beer
+
+        k=[]
+        ANYONE.likes(X).each{|x|k << x}
+        k.should == [:beer]
+
+        k=[]
+        X.likes(ANYTHING).each{|x|k << x}
+        k.should == [:john]
+      end
+
+      it "makes sure all variables are instantiated" do
+        res = []
+        A.likes(B).if {|a,b| res << a << b }
+        A.likes? :beer
+        res.should == [nil,:beer]
+      end
+
+      it "substitutes deeper variables" do
+        res = []
+        A.likes(B).if {|a,b| res << a << b }
+        (A.is(:john).and B.is(:swimming.in C).and 
+         C.is(:sea).and A.likes B).to_a.should == [[:john,:swimming.in(:sea),:sea]]
+        res.should == [:john, :swimming.in(:sea)]
+      end
+
+
+      describe "support Enumerable" do
+        before do
+          :john.likes! :beer
+          :john.likes! :milk
+        end
+
+        it "#all?, #any? and #none?" do
+          (:john.likes A).all?{|a| Symbol===a}.should be_true
+          (:john.likes A).all?{|a| a == :beer}.should be_false
+          (:john.likes A).all?{|a| a == :beer or a == :milk}.should be_true
+          (:john.likes A).any?{|a| a == :beer}.should be_true
+          (:john.likes A).any?{|a| a == :milk}.should be_true
+          (:john.likes A).any?{|a| a == :water}.should be_false
+          (:john.likes A).none?{|a| a == :water}.should be_true
+          (:john.likes A).none?{|a| a == :beer}.should be_false
+        end
+
+        it "#to_a" do
+          (:john.likes A).to_a.should == [:beer, :milk]
+          (X.likes A).to_a.should == [[:john, :beer], [:john, :milk]]
+          (ANYONE.likes A).to_a.should == [:beer, :milk]
+        end
+
+        it "#first" do
+          (:john.likes A).first.should == :beer
+        end
+
+        it "#map" do
+          (:john.likes A).map{|a|a.to_s}.should == ['beer', 'milk']
+        end
+
+        it "#include? and #member?" do
+          (:john.likes B).member?(:beer).should be_true
+          (:john.likes B).include?(:beer).should be_true
+          (:john.likes B).member?(:milk).should be_true
+          (:john.likes B).include?(:milk).should be_true
+          (:john.likes B).member?(:water).should be_false
+          (:john.likes B).include?(:water).should be_false
+        end
+        
+      end
+
+      it "can yield solutions with vars substituted" do
+        :john.likes! :beer
+        :john.likes! :milk
+        :jane.likes! :milk
+
+        (A.likes B).solutions.should == [
+          :john.likes(:beer),
+          :john.likes(:milk),
+          :jane.likes(:milk)
+        ]
+        (A.likes(B).and A.is :john).solutions.should == [
+          :john.likes(:beer).and(:john.is :john),
+          :john.likes(:milk).and(:john.is :john)
+        ]
+        (:john.likes(B)).solutions.should == [
+          :john.likes(:beer),
+          :john.likes(:milk)
+        ]
+        (A.likes(:milk)).solutions.should == [
+          :john.likes(:milk),
+          :jane.likes(:milk)
+        ]
+      end
+
+    end

data/spec/recursion_spec.rb

@@ -1,10 +1,10 @@
 
 require 'rubylog'
 
-class << Rubylog.theory
-  describe "recursion" do
-    specify "factorial" do
-      Integer.rubylog_functor :factorial
+describe "recursion" do
+  specify "factorial" do
+    theory "Recursion" do
+      functor_for Integer, :factorial
       0.factorial! 1
       N.factorial(K).if lambda{|n|n>0}.and N1.is{|n|n-1}.and N1.factorial(K1).and K.is{|n,_,_,k1|k1*n}
 

data/spec/ruby_code_spec.rb

@@ -0,0 +1,52 @@
+
+    describe "using ruby code in clauses" do
+      it "works" do
+        (:true.and? {false}).should be_false
+        (:true.and? {true}).should be_true
+        (:false.and? {false}).should be_false
+        (:false.and? {true}).should be_false
+        (:true.or? {false}).should be_true
+        (:true.or? {true}).should be_true
+        (:false.or? {false}).should be_false
+        (:false.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
+        (:false.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 {|*args| result = args})
+          (: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 {|*args| result = args})
+          (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 {|*args| result = args}).solve{}
+          result.should == [1,2]
+        end
+
+
+
+      end
+    end

data/spec/rules_spec.rb

@@ -0,0 +1,97 @@
+
+    describe "rules" do
+      describe "with prolog body" do
+        it "cannot be asserted in a builtin's desc" do
+          lambda {
+            :john.likes(:beer).and! :jane.likes(:milk)
+          }.should raise_error(Rubylog::BuiltinPredicateError)
+        end
+
+        it "can be asserted with if" do
+          Rubylog.theory.predicate [:we_have, 2]
+          :john.is_happy.if :-@.we_have(:beer)
+          :john.is_happy?.should be_false
+          :-@.we_have!(:beer)
+          :john.is_happy?.should be_true
+        end
+
+        it "can be asserted with unless" do
+          Rubylog.theory.predicate [:we_have, 2]
+          :john.is_happy.unless :-@.we_have(:problem)
+          :john.is_happy?.should be_true
+          :-@.we_have!(:problem)
+          :john.is_happy?.should be_false
+        end
+
+        it "can do simple general implications" do
+          Rubylog.theory.predicate [:is_happy,1], [:has,2]
+          Rubylog.theory.discontinuous [:likes,2]
+          X.is_happy.if X.likes(Y).and X.has(Y)
+          :john.likes! :milk
+          :john.is_happy?.should be_false
+          :john.has! :beer
+          :john.is_happy?.should be_false
+          :john.likes! :beer
+          :john.is_happy?.should be_true
+        end
+
+        it "can yield implied solutions" do
+          X.brother(Y).if X.father(Z).and Y.father(Z).and X.neq(Y)
+          X.uncle(Y).if X.father(Z).and Z.brother(Y)
+          X.neq(Y).if proc {|x,y|x != y}
+
+          :john.father! :dad
+          :jack.father! :dad
+          :dad.father! :grandpa
+          :jim.father! :grandpa
+
+          (:john.brother X).to_a.should == [:jack]
+          (:john.father X).to_a.should == [:dad]
+          (X.father :dad).to_a.should == [:john, :jack]
+          (ANY.father X).to_a.should == [:dad, :dad, :grandpa, :grandpa]
+          (:john.uncle X).to_a.should == [:jim]
+        end
+      end
+
+      describe "with ruby body" do
+        it "can be asserted (true)" do
+          :john.is_happy.if proc{ true }
+          :john.is_happy?.should be_true
+        end
+        it "can be asserted (false)" do
+          :john.is_happy.if proc{ false }
+          :john.is_happy?.should be_false
+        end
+
+        it "can be asserted implicitly (true)" do
+          :john.is_happy.if { true }
+          :john.is_happy?.should be_true
+        end
+
+        it "can be asserted implicitly (false)" do
+          :john.is_happy.if { false }
+          :john.is_happy?.should be_false
+        end
+
+        it "run the body during every query" do
+          count = 0
+          :john.is_happy.if proc{ count += 1 }
+          count.should == 0
+          :john.is_happy?
+          count.should == 1
+          :john.is_happy?
+          count.should == 2
+        end
+
+        it "can take arguments" do
+          (A.divides B).if proc{|a,b| b % a == 0}
+          (4.divides? 16).should be_true
+          (4.divides? 17).should be_false
+          (4.divides? 18).should be_false
+          (3.divides? 3).should be_true
+          (3.divides? 4).should be_false
+          (3.divides? 5).should be_false
+          (3.divides? 6).should be_true
+        end
+      end
+    end

data/spec/spec_helper.rb

@@ -1,6 +1,10 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$:.unshift(File.dirname(__FILE__))
 require 'rspec'
+
+require 'simplecov'
+SimpleCov.start
+
 require 'rubylog'
 
 # Requires supporting files with custom matchers and macros, etc,

data/spec/theory_spec.rb

@@ -1 +1,29 @@
+theory "Th" do
+  subject Symbol
+  functor \
+    :likes, :is_happy, :in, :has, :we_have,
+    :brother, :father, :uncle, :neq, :happy, :%
+end
 
+
+describe "facts" do
+  it "can be asserted with assert" do
+    Th.assert(:john.is_happy)
+    Th[[:is_happy,1]].should include(Rubylog::Clause.new :-, :john.is_happy, :true)
+    Th.assert(:john.likes :beer)
+    Th[[:likes,2]].should include(Rubylog::Clause.new :-, :john.likes(:beer), :true)
+    Th.assert(:john.likes :drinking.in :bar)
+    Th[[:likes,2]].should include(:john.likes(:drinking.in :bar) - :true)
+  end
+
+  it "can be asserted with a bang, and it returns the zeroth arg" do
+    :john.is_happy!.should == :john
+    Th[[:is_happy,1]].should include(:john.is_happy.-:true)
+    :john.likes!(:beer).should == :john
+    Th[[:likes,2]].should include(:john.likes(:beer).-:true)
+    :john.likes!(:drinking.in :bar).should == :john
+    Th[[:likes,2]].should include(:john.likes(:drinking.in :bar).-:true)
+  end
+
+
+end