rubylog 1.0.0 → 2.0pre1

data/spec/builtins/branch_or_spec.rb

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

data/spec/builtins/cut_spec.rb

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

data/spec/builtins/fail_spec.rb

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

data/spec/builtins/false_spec.rb

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

data/spec/builtins/in_spec.rb

@@ -1,38 +0,0 @@
-
-      describe "in" do
-        before do
-          :john.likes! :beer
-          :jane.likes! :milk
-        end
-
-        it "works for variables" do
-          (A.likes(B).and(B.in [])).to_a.should == []
-          (A.likes(B).and(B.in [:milk])).to_a.should == [[:jane, :milk]]
-          (A.likes(B).and(B.in [:beer])).to_a.should == [[:john, :beer]]
-          (A.likes(B).and(B.in [:milk, :beer])).to_a.should == [[:john, :beer], [:jane, :milk]]
-        end
-
-        it "works with blocks" do
-          (A.likes(B).and(B.in {[]})).to_a.should == []
-          (A.likes(B).and(B.in {|a|[a,:milk]})).to_a.should == [[:jane, :milk]]
-          (A.likes(B).and(B.in {|a,b|[:beer]})).to_a.should == [[:john, :beer]]
-          (A.likes(B).and(B.in {|a,b|[b]})).to_a.should == [[:john, :beer], [:jane, :milk]]
-        end
-
-        it "works as iterator" do
-          (A.in{[1,3,4]}).to_a.should == [1,3,4]
-          (A.in [1,3,4]).to_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)}).to_a.should == [[:john, :beer]]
-        end
-
-      end

data/spec/builtins/is_false_spec.rb

@@ -1,12 +0,0 @@
-
-      describe "is_false" do
-        it "works 5" do
-          :john.happy.if :true.is_false
-          :john.should_not be_happy
-        end
-
-        it "works 5" do
-          :john.happy.if :fail.is_false
-          :john.should be_happy
-        end
-      end

data/spec/builtins/is_spec.rb

@@ -1,26 +0,0 @@
-
-      describe "is" do
-        before do
-          :john.likes! :beer
-          :jane.likes! :milk
-        end
-
-        it "works for variables" do
-          (A.likes(B).and(B.is :milk)).to_a.should == [[:jane, :milk]]
-          (A.likes(B).and(:milk.is B)).to_a.should == [[:jane, :milk]]
-        end
-
-        it "works as calculation" do
-          (A.is {|| 4+4}).to_a.should == [8]
-          (A.is {4+4}).to_a.should == [8]
-          (A.is(4).and A.is{2*2}).to_a.should == [4]
-          (A.is(4).and A.is{2*3}).to_a.should == []
-        end
-
-        it "works as calculation with vars" do
-          (A.is(4).and B.is{|a|a*4}).to_a.should == [[4,16]]
-          (A.is(4).and A.is{|a|a*1}).to_a.should == [4]
-          (A.is(4).and A.is{|a|a*2}).to_a.should == []
-        end
-
-      end

data/spec/builtins/matches_spec.rb

@@ -1,23 +0,0 @@
-
-      describe "matches" do
-        before do
-          :john.likes! "Beer"
-          :jane.likes! "Water"
-        end
-
-        it "works for variables" do
-          (A.likes(B).and(B.matches /e/)).to_a.should == [[:john, "Beer"], [:jane, "Water"]]
-          (A.likes(B).and(B.matches /ee/)).to_a.should == [[:john, "Beer"]]
-          (A.likes(B).and(B.matches /w/i)).to_a.should == [[:jane, "Water"]]
-        end
-
-        it "works as calculation" do
-          (A.likes(B).and(B.matches {|a,b|/e/})).to_a.should == [[:john, "Beer"], [:jane, "Water"]]
-          (A.likes(B).and(B.matches {|a,b|/ee/})).to_a.should == [[:john, "Beer"]]
-          (A.likes(B).and(B.matches {|a,b|/w/i})).to_a.should == [[:jane, "Water"]]
-          (A.likes(B).and(B.matches {|a,b|b})).to_a.should == [[:john, "Beer"], [:jane, "Water"]]
-          (A.likes(B).and(B.matches {|a,b|a})).to_a.should == []
-        end
-
-
-      end

data/spec/builtins/or_spec.rb

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

data/spec/builtins/splits_to.rb

@@ -1,18 +0,0 @@
-require 'rubylog'
-
-class << Rubylog.theory
-  describe "splits_to" do
-    specify do
-      def split_to a,b
-        be_splits_to a,b
-      end
-
-      [].should_not split_to(ANY,ANY)
-      [1].should split_to(1,[])
-      [1,2].should split_to(1,[2])
-      [1,2,3].should split_to(1,[2,3])
-
-      ([1,2,3].splits_to(B,C)).to_a.should == [[1,[2,3]]]
-    end
-  end
-end

data/spec/builtins/then_spec.rb

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

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

data/spec/compilation_spec.rb

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

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

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

data/spec/queries_spec.rb

@@ -1,150 +0,0 @@
-
-    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,18 +0,0 @@
-
-require 'rubylog'
-
-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}
-
-      (0.factorial K).to_a.should == [1]
-      (1.factorial K).to_a.should == [1]
-      (2.factorial K).to_a.should == [2]
-      (3.factorial K).to_a.should == [6]
-      (4.factorial K).to_a.should == [24]
-    end
-  end
-end

data/spec/ruby_code_spec.rb

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