rubylog 1.0.0 → 2.0pre1

data/spec/integration/custom_classes_spec.rb

@@ -0,0 +1,61 @@
+require "spec_helper"
+
+describe "custom classes" do
+  before do
+    class User
+      extend Rubylog::Context
+      predicate ".girl .boy"
+
+      attr_reader :name
+      def initialize name
+        @name = name
+      end
+      
+      U.girl.if { U.name =~ /[aeiouh]$/ }
+      U.boy.unless U.girl
+
+      def long_hair?
+        girl?
+      end
+
+      def hello
+        "Hello #{U.is(self).and(U.girl).true? ? "Ms." : "Mr."} #{@name}!"
+      end
+
+
+    end
+  end
+
+  it "can have ruby predicates" do
+    john = User.new "John"
+    john.girl?.should be_false
+    john.boy?.should be_true
+    john.long_hair?.should be_false
+
+    jane = User.new "Jane"
+    jane.girl?.should be_true
+    jane.boy?.should be_false
+    jane.long_hair?.should be_true
+  end
+  
+  it "can be used in assertions" do
+    pete = User.new "Pete"
+    pete.boy?.should be_false
+    pete.boy!
+    pete.boy?.should be_true
+
+    janet = User.new "Janet"
+    janet.girl?.should be_false
+    janet.girl!
+    janet.girl?.should be_true
+  end
+
+  it "can use variables in instance methods" do
+    User.new("John").hello.should == "Hello Mr. John!"
+    User.new("Jane").hello.should == "Hello Ms. Jane!"
+  end
+
+
+
+
+end

data/spec/integration/dsl_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper" 
+
+describe "Rubylog dsl", :rubylog=>true do
+
+  describe "prefix functors" do
+    before do
+      predicate_for singleton_class, ".we_have()"
+      we_have! :weapons
+      we_have! :sunglasses
+      we_have! :rustling_leather_coats
+    end
+
+    it "works" do
+      check we_have :sunglasses
+    end
+    
+    it "works with qmarks" do
+      check { we_have? :rustling_leather_coats }
+    end
+  end
+
+
+  describe "built-in prefix functors" do
+    check all X.is(4).and(Y.is(X)), Y.is(4)
+    check any X.is(4)
+    check one(X.in([1,2,3])) { X % 2  == 0 }
+    check none X.in([1,2,3]), X.is(5)
+    check { all?(X.is(4)) { X < 5 } }
+  end
+
+  describe "variables" do
+    check A.is(ANY).and{ A == Rubylog::Variable.new(:A) }
+    check A.is(4)  .and{ A == 4 }
+    check B.is(A)  .and{ A == Rubylog::Variable.new(:B) and B == Rubylog::Variable.new(:B) }
+    check B.is(ANY).and{ A == Rubylog::Variable.new(:A) }
+  end
+
+end

data/spec/integration/recursion_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe "Recursion", :rubylog=>true do
+  predicate_for Integer, ".factorial()"
+  0.factorial! 1
+  N[thats > 0].factorial(K).if N1.is {N-1} .and N1.factorial(K1).and K.is{ N*K1 }
+
+  check 0.factorial 1
+  check 1.factorial 1
+  check 2.factorial 2
+  check 3.factorial 6
+  check 4.factorial 24
+  check 7.factorial 5040
+end

data/spec/integration/theory_as_module_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+extend Rubylog::Context
+
+predicate_for Integer, %w(.divides())
+
+(A[thats > 0].divides B[thats > 0]).if { B%A == 0 }
+
+(N.is 210).solve do
+
+  (I.in [1, 2, 3, 5, 6, 7, 10, 14, 15, 21, 30, 35, 42, 70, 105, 210]).each do
+    check(I.divides N)
+  end
+
+  (I.in [4, 8, 9, 11, 12, 20, 31]).each do
+    check( (I.divides N).false )
+  end
+
+end
+

data/spec/integration/theory_as_module_with_include_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+
+class MyClass
+  include Rubylog::Context
+end
+
+a=MyClass.new
+
+a.instance_eval do
+  predicate_for Integer, %w(.divides())
+  (N.divides M).if { M%N == 0 }
+
+  check 23.divides(230)
+end

data/spec/rspec/rubylog_spec.rb

@@ -0,0 +1,75 @@
+require "spec_helper"
+
+describe "Rubylog", :rubylog => true do
+
+  predicate_for Integer, ".even"
+
+  N.even.if { N%2 == 0 }
+
+  it "checks for true statements" do
+    check :true
+  end
+
+  it "raises an exception for false statements" do
+    proc{check :fail}.should raise_exception(Rubylog::CheckFailed)
+
+    self.default_subject = Integer
+    proc{check 4.is 5}.should raise_exception(Rubylog::CheckFailed)
+  end
+
+  it "can use variables" do
+    check A.is 3
+  end
+
+  it "can use predicates" do
+    check((A.in [1,2]).and(B.in([2,3])).and(A.is 1).and(B.is 3))
+  end
+
+  it "can assert predicates" do
+    predicate_for Integer, ".divides()"
+    (A.divides B).if {B%A == 0}
+    check(4.divides 12)
+    check((4.divides 30).false)
+  end
+
+  it "can use predicates defined outside" do
+    check 1.even.false
+    check 2.even
+  end
+
+  describe "nested check" do
+    it "works" do
+      check 9.even.false
+    end
+  end
+
+  # inline check
+  check 0.even
+  
+  describe "nested inline check" do
+    check 3.even.false
+    check 4.even
+  end
+
+end
+
+describe "Rubylog" do
+  describe "when not included" do
+
+    it "does not add methods" do
+      proc{check :true}.should raise_exception NameError
+      proc{trace}.should raise_exception NameError
+    end
+
+    it "does not add constants" do
+      proc{A}.should raise_exception NameError
+    end
+
+  end
+end
+
+
+
+#require "rspec/core/formatters/progress_formatter"
+#require "rspec/core/formatters/documentation_formatter"
+#EG.run RSpec::Core::Reporter.new RSpec::Core::Formatters::DocumentationFormatter.new(STDOUT) 

data/spec/rubylog/assertable_spec.rb

@@ -0,0 +1,111 @@
+require "spec_helper"
+
+describe "rules", :rubylog=>true do
+  before do
+    predicate_for Symbol, ".likes(Drink) .is_happy .has()"
+    predicate_for_context ".we_have()"
+  end
+
+  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
+    end
+
+    it "can be asserted with if" do
+      :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
+      :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
+      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
+      predicate_for Symbol, ".brother() .father() .uncle()"
+      X.brother(Y).if X.father(Z).and Y.father(Z).and {X != Y}
+      X.uncle(Y).if X.father(Z).and Z.brother(Y)
+
+      :john.father! :dad
+      :jack.father! :dad
+      :dad.father! :grandpa
+      :jim.father! :grandpa
+
+      (:john.brother X).map{X}.should == [:jack]
+      (:john.father X).map{X}.should == [:dad]
+      (X.father :dad).map{X}.should == [:john, :jack]
+      (ANY.father X).map{X}.should == [:dad, :dad, :grandpa, :grandpa]
+      (:john.uncle X).map{X}.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
+      predicate_for Integer, ".divides()"
+      (A.divides B).if proc{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
+
+  describe "#if!" do
+    it "can be used to cut off branches" do
+      predicate_for Integer, ".divides()"
+      1.divides(X).if! :true
+      (A.divides B).if proc{B % A == 0}
+      1.divides(4).map{}.should == [nil]
+      2.divides(4).map{}.should == [nil]
+    end
+  end
+end

data/spec/rubylog/builtins/arithmetics_spec.rb

@@ -0,0 +1,94 @@
+require "spec_helper"
+
+describe "Arithmetics builtins", :rubylog=>true do
+  check 5.sum_of 2, 3
+
+  check((5.sum_of 2, 6).false)
+
+  check { 5.sum_of(3, A).map{A}.eql? [2] }
+  check { 5.sum_of(A, 2).map{A}.eql? [3] }
+  check { A.sum_of(3, 4).map{A}.eql? [7] }
+
+  check A.is(5).and B.is(3).and C.is(2).and A.sum_of(C, B)
+
+  it "works with functions" do
+    check A.is(5).and 5.sum_of(proc{2}, proc{A-2})
+    check A.is(5).and 5.sum_of(proc{3}, proc{A-2}).false
+  end
+
+  it "checks types" do
+    check 4.sum_of(2,2.0).false
+    check 4.0.sum_of(2.0,2.0)
+  end
+
+  it "can add strings" do
+    A.sum_of(B,C).predicate.add_functor_to String
+    check "hello".sum_of("he", "llo")
+  end
+
+  it "can add arrays" do
+    A.sum_of(B,C).predicate.add_functor_to Array
+    check [1,2,3].sum_of([1,2], [3])
+  end
+
+  it "can subtract arrays" do
+    A.sum_of(B,C).predicate.add_functor_to Array
+    [1,2,3].sum_of(X, [3]).map{X}.should be_eql [[1,2]]
+  end
+
+  it "can multiply integers" do
+    A.product_of(3,2).map{A}.should be_eql [6]
+  end
+
+  it "can divide integers" do
+    6.product_of(A,2).map{A}.should be_eql [3]
+  end
+
+  it "can divide integers" do
+    6.product_of(3,A).map{A}.should be_eql [2]
+  end
+
+  it "can divide floats" do
+    6.0.product_of(A,2.0).map{A}.should be_eql [3.0]
+  end
+
+  it "can divide floats" do
+    6.0.product_of(3.0,A).map{A}.should be_eql [2.0]
+  end
+
+  it "checks non-divisibility of integers" do
+    6.product_of(5,A).map{A}.should be_eql []
+  end
+
+  it "checks non-divisibility of integers" do
+    6.product_of(A,4).map{A}.should be_eql []
+  end
+
+  it "casts types" do
+    6.0.product_of(A,2).map{A}.should be_eql [3.0]
+  end
+
+  it "casts types" do
+    6.0.product_of(3,A).map{A}.should be_eql [2.0]
+  end
+
+  it "casts types" do
+    A.product_of(3,2.0).map{A}.should be_eql [6.0]
+  end
+
+  it "checks instatiation" do
+    expect { 8.product_of(B,C).map{[B,C]} }.to raise_error Rubylog::InstantiationError
+  end
+  
+  it "checks instatiation" do
+    expect { 8.sum_of(B,C).map{[B,C]} }.to raise_error Rubylog::InstantiationError
+  end
+
+  it "checks instatiation" do
+    expect { A.sum_of(B,2).map{[B,C]} }.to raise_error Rubylog::InstantiationError
+  end
+
+  it "checks instatiation" do
+    expect { A.product_of(B,2).map{[B,C]} }.to raise_error Rubylog::InstantiationError
+  end
+end

data/spec/rubylog/builtins/assumption_spec.rb

@@ -0,0 +1,70 @@
+require "spec_helper"
+
+describe "Assumption builtins", :rubylog=>true do
+  before do
+    predicate_for Integer, ".divides() .perfect"
+    A.divides(B).if { B%A == 0 }
+    N.perfect.if { (A.in{1...N}.and A.divides(N)).map{A}.inject{|a,b|a+b} == N }
+  end
+
+  specify do 
+    check 4.perfect.false
+    check 5.perfect.false
+    check 6.perfect
+    check 7.perfect.false
+  end
+
+  describe "assumed" do
+    specify do
+      check 4.divides(6).assumed.and 6.perfect.false
+      check 2.divides(3).assumed.and 3.perfect
+      check 4.perfect.assumed.and 4.perfect
+      check ANY.perfect.assumed.and 4.perfect
+      check ANY.perfect.assumed.and 17.perfect
+    end
+  end
+
+  describe "rejected" do
+    specify do
+      check 4.divides(6).rejected.and 6.perfect
+      check 3.divides(6).rejected.and 6.perfect.false
+      check 2.divides(20).rejected.and 20.perfect
+    end
+  end
+
+  describe "revoked" do
+    before do
+      predicate_for String, ".likes()"
+      'John'.likes! 'milk'
+      'John'.likes! 'beer'
+    end
+
+    specify { 'John'.likes(A).map{A}.should == ['milk','beer'] }
+    specify { 
+      'John'.likes('milk').revoked.and('John'.likes(A)) \
+      .map{A}.should == ['beer'] }
+    specify { 
+      'John'.likes('beer').revoked.and('John'.likes(A)) \
+      .map{A}.should == ['milk'] }
+    specify { 
+      'John'.likes('water').revoked.true?.should be_false }
+    specify { 
+      'John'.likes(X).revoked.map{X}.should == ['milk','beer'] }
+    specify { 'John'.likes(A).map{A}.should == ['milk','beer'] }
+  end
+
+  describe "assumed unless" do
+    xspecify
+  end
+  describe "rejected" do
+    xspecify
+  end
+  describe "rejected_if" do
+    xspecify
+  end
+  describe "rejected_unless" do
+    xspecify
+  end
+end
+
+

data/spec/rubylog/builtins/ensure_spec.rb

@@ -0,0 +1,8 @@
+require "spec_helper"
+
+describe "ensure builtin", :rubylog=>true do
+  k = 6
+  check proc{k=5}.ensure{k=6}.and{k.eql? 5}
+  check {k.eql? 6}
+end
+

data/spec/rubylog/builtins/file_system_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe "file system builtins", :rubylog=>true do
+  specify "directories are files" do
+    check "./lib".file_in(".")
+  end
+
+  specify ": regular files are files" do
+    check "./README.rdoc".file_in(".")
+  end
+
+  specify ": regular files are not directories" do
+    check "./README.rdoc".dir_in(".").false
+  end
+
+  specify "#filename_in" do
+    check "rubylog.rb".filename_in("lib")
+  end
+
+  specify "#dirname_in" do
+    check "rubylog".dirname_in("lib")
+  end
+
+  specify ": works with variable filename" do
+    A.dir_in(".").map{A}.should include "./lib"
+  end
+
+  specify ": works with variable dir" do
+    "./lib/rubylog.rb".file_in(D).map{D}.should == ["./lib"]
+  end
+
+  specify ": works with function dir" do
+    FN.file_in{"./lib"}.map{FN}.should include "./lib/rubylog.rb"
+  end
+
+  specify ": works with partial strings" do
+    "./lib/#{A}.rb".file_in("./lib").map{A}.should == ["rubylog"]
+  end
+
+end