rubylog 0.0.1 → 1.0.0

data/rubylog.gemspec

@@ -4,16 +4,18 @@
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
-  s.name = %q{rubylog}
-  s.version = "0.0.1"
+  s.name = "rubylog"
+  s.version = "1.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Bern\303\241t Kall\303\263"]
-  s.date = %q{2012-02-07}
-  s.description = %q{Rubylog is an embedded Prolog language and interpreter for Ruby.}
-  s.email = %q{kallo.bernat@gmail.com}
+  s.authors = ["Bern\u{e1}t Kall\u{f3}"]
+  s.date = "2013-02-27"
+  s.description = "Rubylog is an embedded Prolog language and interpreter for Ruby."
+  s.email = "kallo.bernat@gmail.com"
+  s.executables = ["rubylog"]
   s.extra_rdoc_files = [
     "LICENSE.txt",
+    "README.hu.rb",
     "README.rdoc"
   ]
   s.files = [
@@ -22,50 +24,86 @@ Gem::Specification.new do |s|
     "Gemfile",
     "Gemfile.lock",
     "LICENSE.txt",
+    "README.hu.rb",
     "README.rdoc",
     "Rakefile",
     "VERSION",
-    "examples/4queens.rb",
-    "examples/calculation.rb",
-    "examples/concepts.rb",
+    "bin/rubylog",
+    "examples/dcg.rb",
+    "examples/dcg2.rb",
+    "examples/enumerators.rb",
     "examples/factorial.rb",
-    "examples/fp.rb",
+    "examples/hanoi.rb",
     "examples/hello.rb",
-    "examples/historia_de_espana.rb",
-    "examples/idea.rb",
-    "examples/lists.rb",
-    "examples/mechanika.rb",
-    "examples/parse.rb",
+    "examples/parsing.rb",
+    "examples/primitives.rb",
     "examples/theory.rb",
-    "lib/array.rb",
-    "lib/class.rb",
-    "lib/method.rb",
-    "lib/object.rb",
-    "lib/proc.rb",
     "lib/rubylog.rb",
-    "lib/rubylog/builtins.rb",
-    "lib/rubylog/callable.rb",
-    "lib/rubylog/clause.rb",
-    "lib/rubylog/composite_term.rb",
+    "lib/rubylog/builtins/default.rb",
+    "lib/rubylog/builtins/file_system.rb",
+    "lib/rubylog/builtins/logic.rb",
+    "lib/rubylog/builtins/reflection.rb",
+    "lib/rubylog/builtins/term.rb",
     "lib/rubylog/dsl.rb",
-    "lib/rubylog/dsl/constants.rb",
-    "lib/rubylog/dsl/first_order_functors.rb",
-    "lib/rubylog/dsl/global_functors.rb",
-    "lib/rubylog/dsl/second_order_functors.rb",
+    "lib/rubylog/dsl/array_splat.rb",
+    "lib/rubylog/dsl/primitives.rb",
+    "lib/rubylog/dsl/thats.rb",
+    "lib/rubylog/dsl/variables.rb",
     "lib/rubylog/errors.rb",
-    "lib/rubylog/internal_helpers.rb",
-    "lib/rubylog/predicate.rb",
-    "lib/rubylog/proc_method_additions.rb",
-    "lib/rubylog/term.rb",
+    "lib/rubylog/interfaces/assertable.rb",
+    "lib/rubylog/interfaces/callable.rb",
+    "lib/rubylog/interfaces/composite_term.rb",
+    "lib/rubylog/interfaces/predicate.rb",
+    "lib/rubylog/interfaces/procedure.rb",
+    "lib/rubylog/interfaces/term.rb",
+    "lib/rubylog/mixins/array.rb",
+    "lib/rubylog/mixins/class.rb",
+    "lib/rubylog/mixins/hash.rb",
+    "lib/rubylog/mixins/kernel.rb",
+    "lib/rubylog/mixins/method.rb",
+    "lib/rubylog/mixins/object.rb",
+    "lib/rubylog/mixins/proc.rb",
+    "lib/rubylog/mixins/string.rb",
+    "lib/rubylog/mixins/symbol.rb",
+    "lib/rubylog/simple_procedure.rb",
+    "lib/rubylog/structure.rb",
     "lib/rubylog/theory.rb",
-    "lib/rubylog/unifiable.rb",
     "lib/rubylog/variable.rb",
-    "lib/symbol.rb",
+    "logic/builtins/file_system_logic.rb",
+    "logic/builtins/reflection_logic.rb",
+    "logic/dereference_logic.rb",
+    "logic/directory_structure_logic.rb",
+    "logic/dsl_logic.rb",
+    "logic/errors_logic.rb",
+    "logic/guard_logic.rb",
+    "logic/list_logic.rb",
+    "logic/map_logic.rb",
+    "logic/multitheory.rb",
+    "logic/recursion_logic.rb",
+    "logic/string_logic.rb",
+    "logic/thats_logic.rb",
+    "logic/variable_logic.rb",
     "rubylog.gemspec",
-    "script/inriasuite2spec",
-    "script/inriasuite2spec.pl",
     "spec/bartak_guide_spec.rb",
-    "spec/inriasuite.rb",
+    "spec/builtins/all_spec.rb",
+    "spec/builtins/and_spec.rb",
+    "spec/builtins/array_spec.rb",
+    "spec/builtins/branch_or_spec.rb",
+    "spec/builtins/cut_spec.rb",
+    "spec/builtins/fail_spec.rb",
+    "spec/builtins/false_spec.rb",
+    "spec/builtins/in_spec.rb",
+    "spec/builtins/is_false_spec.rb",
+    "spec/builtins/is_spec.rb",
+    "spec/builtins/matches_spec.rb",
+    "spec/builtins/or_spec.rb",
+    "spec/builtins/splits_to.rb",
+    "spec/builtins/then_spec.rb",
+    "spec/builtins/true_spec.rb",
+    "spec/clause_spec.rb",
+    "spec/compilation_spec.rb",
+    "spec/custom_classes_spec.rb",
+    "spec/dereference.rb",
     "spec/inriasuite/README",
     "spec/inriasuite/abolish",
     "spec/inriasuite/and",
@@ -133,22 +171,23 @@ Gem::Specification.new do |s|
     "spec/inriasuite/term_lt=",
     "spec/inriasuite/true",
     "spec/inriasuite/unify",
+    "spec/inriasuite_spec.rb",
+    "spec/queries_spec.rb",
     "spec/recursion_spec.rb",
-    "spec/rubylog/builtins/splits_to.rb",
-    "spec/rubylog/clause_spec.rb",
-    "spec/rubylog/variable_spec.rb",
-    "spec/rubylog_spec.rb",
+    "spec/ruby_code_spec.rb",
+    "spec/rules_spec.rb",
     "spec/spec_helper.rb",
-    "spec/theory_spec.rb"
+    "spec/theory_spec.rb",
+    "spec/unification_spec.rb",
+    "spec/variable_spec.rb"
   ]
-  s.homepage = %q{https://github.com/cie/rubylog}
+  s.homepage = "https://github.com/cie/rubylog"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{An embedded Prolog interpreter}
+  s.rubygems_version = "1.8.15"
+  s.summary = "An embedded Prolog interpreter"
 
   if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then

data/spec/bartak_guide_spec.rb

@@ -4,88 +4,83 @@
 
 require 'rubylog'
 
-class << Rubylog.theory
-  describe Rubylog do
-    before do
-      Rubylog.theory.clear
-    end
-
-    specify "Genealogy database" do
-      Symbol.rubylog_functor :man, :woman
-
-      :adam.man!
-      :peter.man!
-      :paul.man!
 
-      :marry.woman!
-      :eve.woman!
+theory "Genealogy" do
+  subject Symbol
+  functor :man, :woman
 
-    end
+  :adam.man!
+  :peter.man!
+  :paul.man!
 
+  :marry.woman!
+  :eve.woman!
+end
 
-    specify "Lists" do
-      Object.rubylog_functor :head_of
-      Array.rubylog_functor :tail_of
+__END__
+theory "Lists" do
+  functor_for Object, :head_of
+  functor_for Array, :tail_of
 
-      H.head_of(A).if A.splits_to(H,ANY)
-      T.tail_of(A).if A.splits_to(ANY,T)
+  H.head_of(A).if A.splits_to(H,ANY)
+  T.tail_of(A).if A.splits_to(ANY,T)
 
-      2.should be_head_of [2,3,4]
-      2.should be_head_of [2]
-      2.should_not be_head_of [1]
-      2.should_not be_head_of []
+  2.should be_head_of [2,3,4]
+  2.should be_head_of [2]
+  2.should_not be_head_of [1]
+  2.should_not be_head_of []
 
-      [3,4].should be_tail_of [2,3,4]
-      [].   should be_tail_of [1]
+  [3,4].should be_tail_of [2,3,4]
+  [].   should be_tail_of [1]
 
-      Object.rubylog_functor :member_of
+  Object.rubylog_functor :member_of
 
-      M.member_of(A).if A.splits_to(M,ANY)
-      M.member_of(A).if A.splits_to(ANY,T).and M.member_of(T)
+  M.member_of(A).if A.splits_to(M,ANY)
+  M.member_of(A).if A.splits_to(ANY,T).and M.member_of(T)
 
-      0.should_not be_member_of [1,2,3]
-      1.should     be_member_of [1,2,3]
-      2.should     be_member_of [1,2,3]
-      3.should     be_member_of [1,2,3]
-      4.should_not be_member_of [1,2,3]
+  0.should_not be_member_of [1,2,3]
+  1.should     be_member_of [1,2,3]
+  2.should     be_member_of [1,2,3]
+  3.should     be_member_of [1,2,3]
+  4.should_not be_member_of [1,2,3]
 
-      Object.rubylog_functor :first_of, :last_of
+  Object.rubylog_functor :first_of, :last_of
 
-      F.first_of(A).if A.splits_to(F,ANY)
-      L.last_of(A).if A.splits_to(L,[])
-      L.last_of(A).if A.splits_to(H,T).and L.last_of(T)
+  F.first_of(A).if A.splits_to(F,ANY)
+  L.last_of(A).if A.splits_to(L,[])
+  L.last_of(A).if A.splits_to(H,T).and L.last_of(T)
 
-      1.should be_first_of [1,2,3]
-      3.should_not be_last_of  []
-      3.should be_last_of  [3]
-      3.should be_last_of  [2,3]
-      3.should be_last_of  [1,2,3]
-      1.should_not be_last_of [1,2,3]
+  1.should be_first_of [1,2,3]
+  3.should_not be_last_of  []
+  3.should be_last_of  [3]
+  3.should be_last_of  [2,3]
+  3.should be_last_of  [1,2,3]
+  1.should_not be_last_of [1,2,3]
 
-      Array.rubylog_functor :prefix_of
+  Array.rubylog_functor :prefix_of
 
-      [].prefix_of! ANY_LIST
-      A.prefix_of(B).if A.splits_to(H,TA).and B.splits_to(H,TB).and TA.prefix_of(TB)
+  [].prefix_of! ANY_LIST
+  A.prefix_of(B).if A.splits_to(H,TA).and B.splits_to(H,TB).and TA.prefix_of(TB)
 
-      [1,2,3].should be_prefix_of [1,2,3]
-    end
+  [1,2,3].should be_prefix_of [1,2,3]
+end
 
 
-    describe "How does it work?" do
+describe "How does it work?" do
 
-      specify "declarative character" do
-        (1.in? [1,2,3]).should be_true
-        (X.in [1,2,3]).to_a.should == [1,2,3]
-        (1.in [X,Y]).to_a.should == [[1,nil], [nil,1]]
-        lists = []
-        (1.in L).each do |l|
-          lists << l
-          break if lists.size == 3
-        end
-        #lists.should == [[1], [nil,1], [nil,nil,1]]
-      end
+  specify "declarative character" do
+    (1.in? [1,2,3]).should be_true
+    (X.in [1,2,3]).to_a.should == [1,2,3]
+    (1.in [X,Y]).to_a.should == [[1,nil], [nil,1]]
+    lists = []
+    (1.in L).each do |l|
+      lists << l
+      break if lists.size == 3
     end
-
+    #lists.should == [[1], [nil,1], [nil,nil,1]]
   end
 end
 
+end
+end
+

data/spec/builtins/all_spec.rb

@@ -0,0 +1,99 @@
+
+      describe "all,any,one,none" 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).to_a.send(:"#{p}?"){|x| m.likes?(x) } ? 1 : 0
+          }}}.should == @good
+        end
+
+
+        
+        it "all works" do
+          (:john.likes(X).all(:john.likes(X))).should stand
+          (:john.likes(X).all(:jane.likes(X))).should stand
+          (:john.likes(X).all(:jeff.likes(X))).should_not stand
+          (:john.likes(X).all(:todd.likes(X))).should_not stand
+
+          (:jane.likes(X).all(:john.likes(X))).should_not stand
+          (:jane.likes(X).all(:jane.likes(X))).should stand
+          (:jane.likes(X).all(:jeff.likes(X))).should_not stand
+          (:jane.likes(X).all(:todd.likes(X))).should_not stand
+
+          (:jeff.likes(X).all(:john.likes(X))).should_not stand
+          (:jeff.likes(X).all(:jane.likes(X))).should_not stand
+          (:jeff.likes(X).all(:jeff.likes(X))).should stand
+          (:jeff.likes(X).all(:todd.likes(X))).should_not stand
+
+          (:todd.likes(X).all(:john.likes(X))).should_not stand
+          (:todd.likes(X).all(:jane.likes(X))).should stand
+          (:todd.likes(X).all(:jeff.likes(X))).should_not stand
+          (:todd.likes(X).all(:todd.likes(X))).should stand
+        end
+
+        it "can be called with global functor syntax" do
+          extend Rubylog::DSL::GlobalFunctors
+          all(:john.likes(X), :jane.likes(X)).should stand
+          all(:jane.likes(X), :john.likes(X)).should_not stand
+          any(:jane.likes(X), :todd.likes(X)).should stand
+          any(:john.likes(X), :todd.likes(X)).should_not stand
+        end
+
+        it "can be called unarily" do
+          extend Rubylog::DSL::GlobalFunctors
+          one(:john.likes(X)).should_not stand
+          one(:jane.likes(X)).should_not stand
+          one(:jeff.likes(X)).should_not stand
+          one(:todd.likes(X)).should stand
+          one(:jim.likes(X)).should_not stand
+
+          any(:john.likes(X)).should stand
+          any(:jane.likes(X)).should stand
+          any(:jeff.likes(X)).should stand
+          any(:todd.likes(X)).should stand
+          any(:jim.likes(X)).should_not stand
+
+          all(:john.likes(X)).should stand
+          all(:jane.likes(X)).should stand
+          all(:jeff.likes(X)).should stand
+          all(:todd.likes(X)).should stand
+          all(:jim.likes(X)).should stand
+
+          none(:john.likes(X)).should_not stand
+          none(:jane.likes(X)).should_not stand
+          none(:jeff.likes(X)).should_not stand
+          none(:todd.likes(X)).should_not stand
+          none(:jim.likes(X)).should stand
+        end
+      end
+
+    end

data/spec/builtins/and_spec.rb

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

data/spec/builtins/array_spec.rb

@@ -0,0 +1,16 @@
+
+    describe "Array" do
+      it "can be unified" do
+        result = false
+        [A,B].rubylog_unify(12) { result = true }
+        result.should == false
+
+        result = false
+        [A,B].rubylog_unify([12,13]) { result = true }
+        result.should == true
+
+        result = false
+        [14,B].rubylog_unify([12,13]) { result = true }
+        result.should == false
+      end
+    end

data/spec/builtins/branch_or_spec.rb

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

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

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

data/spec/builtins/false_spec.rb

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

data/spec/builtins/in_spec.rb

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

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

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

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

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