rubylog 0.0.1 → 1.0.0

data/lib/rubylog.rb

@@ -1,39 +1,47 @@
-# rubylog.rb -- Prolog workalike for Ruby
+# rubylog -- Prolog workalike for Ruby
 # github.com/cie/rubylog
+module Rubylog
+end
 
 # rtl
 require 'set'
 
+dir = File.dirname(__FILE__) + "/"
+
 # interfaces
-require 'rubylog/term.rb'
-require 'rubylog/callable.rb'
-require 'rubylog/unifiable.rb'
-require 'rubylog/composite_term.rb'
+require dir+'rubylog/interfaces/term'
+require dir+'rubylog/interfaces/callable'
+require dir+'rubylog/interfaces/assertable'
+require dir+'rubylog/interfaces/composite_term'
+require dir+'rubylog/interfaces/predicate'
+require dir+'rubylog/interfaces/procedure'
 
 # helpers
-require 'rubylog/dsl.rb'
-require 'rubylog/dsl/constants.rb'
-require 'rubylog/dsl/first_order_functors.rb'
-require 'rubylog/dsl/global_functors.rb'
-require 'rubylog/dsl/second_order_functors.rb'
-require 'rubylog/proc_method_additions.rb'
-require 'rubylog/internal_helpers.rb'
+require dir+'rubylog/dsl'
+require dir+'rubylog/dsl/variables'
+require dir+'rubylog/dsl/primitives'
+require dir+'rubylog/dsl/array_splat'
+require dir+'rubylog/dsl/thats'
+require dir+'rubylog/errors'
 
 # classes
-require 'rubylog/errors.rb'
-require 'rubylog/predicate.rb'
-require 'rubylog/theory.rb'
-require 'rubylog/variable.rb'
+require dir+'rubylog/theory'
+require dir+'rubylog/simple_procedure'
+require dir+'rubylog/variable'
+require dir+'rubylog/structure'
 
 # builtins
-require 'rubylog/builtins.rb'
+require dir+'rubylog/builtins/default'
+
+# mixins
+require dir+'rubylog/mixins/array'
+require dir+'rubylog/mixins/class'
+require dir+'rubylog/mixins/hash'
+require dir+'rubylog/mixins/kernel'
+require dir+'rubylog/mixins/method'
+require dir+'rubylog/mixins/object'
+require dir+'rubylog/mixins/proc'
+require dir+'rubylog/mixins/string'
+require dir+'rubylog/mixins/symbol'
 
-require 'rubylog/clause.rb'
-require 'array.rb'
-require 'symbol.rb'
-require 'proc.rb'
-require 'object.rb'
-require 'class.rb'
-require 'method.rb'
 
-Rubylog::Theory.new!

data/logic/builtins/file_system_logic.rb

@@ -0,0 +1,23 @@
+require "./lib/rubylog/builtins/file_system"
+
+theory do
+  check "lib".dirname_in(".")
+  check "lib".filename_in(".").false
+  check "README.rdoc".filename_in(".")
+  check "README.rdoc".dirname_in(".").false
+  check (Dir.pwd+"/lib").dir_in(".")
+  check (Dir.pwd+"/lib").file_in(".").false
+  check (Dir.pwd+"/README.rdoc").file_in(".")
+  check (Dir.pwd+"/README.rdoc").dir_in(".").false
+  check (Dir.pwd+"/lib/rubylog.rb").file_in("lib")
+  check (Dir.pwd+"/lib/rubylog").dir_in("lib")
+  check "rubylog.rb".filename_in("lib")
+  check "rubylog".dirname_in("lib")
+
+
+  # this is removed in favor of string unification
+  #check "rubylog.rb".filename("rubylog", "rb")
+  #check A.filename("rubylog", "rb").and A.is "rubylog.rb"
+  #check "rubylog.rb".filename(F, "rb").and F.is "rubylog"
+  #check "rubylog.rb".filename("rubylog", E).and E.is "rb"
+end

data/logic/builtins/reflection_logic.rb

@@ -0,0 +1,40 @@
+require "./lib/rubylog/builtins/reflection.rb"
+
+theory do
+  functor_for String, :likes, :drinks
+
+  # fact
+  "John".likes! "beer"
+  check "John".likes("beer").fact
+  check { A.likes(B).fact.map{A.likes(B)} == ["John".likes("beer")] }
+
+  # follows_from
+  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)] }
+
+  # structure
+  check A.likes(B).structure(:likes, [A,B])
+  check { A.likes(B).structure(X,Y).map{[X,Y]} == [[:likes, [A,B]]] }
+
+  # structures with variable functor and partial argument list
+  check { K.structure(:drinks, ["John", "beer"]).map{K} == ["John".drinks("beer")] }
+  check { K.structure(A,[*B]).
+    and(A.is(:drinks)).
+    and(B.is(["John","beer"])).
+    map{K} == ["John".drinks("beer")] }
+
+  # variable
+  # Removed because of the "every built-in prediate is pure logical" principle
+  #check A.variable("A")
+  #check A.variable("B").false
+  #check { A.variable(B).map{B} == ["A"] }
+  # You can use the fact that automatic variable resolution yields nil if the
+  # variable is undefined:
+  #
+  #     check A.is(ANY).and{ A }.false
+  #     check A.is(ANY).and{ not A }
+  #
+
+
+end

data/logic/dereference_logic.rb

@@ -0,0 +1,23 @@
+theory do
+  functor_for Integer, :divides
+
+  check { A.is_a? Rubylog::Variable }
+  check { A.rubylog_deep_dereference == A }
+
+  a = A
+  check { a.rubylog_deep_dereference.equal? a }
+
+  a.rubylog_unify(4) do
+    check { a.rubylog_deep_dereference == 4 }
+    check { [1,a].rubylog_deep_dereference == [1,4] }
+    check { a.divides(16).rubylog_deep_dereference == 4.divides(16) }
+  end
+
+  b = []
+  check { not b.rubylog_deep_dereference.equal? b }
+
+  c = Object.new
+  check { c.rubylog_deep_dereference.equal? c }
+end
+
+

data/logic/directory_structure_logic.rb

@@ -0,0 +1,19 @@
+require "./lib/rubylog/builtins/file_system"
+
+theory do
+  subject String
+  functor :dir, :contains
+  check_discontiguous false
+
+  ".git".dir!.contains! "Git repository"
+  "bin".dir!.contains! "executables"
+  "examples".dir!.contains! "examples and ideas for different applications of Rubylog"
+  "lib".dir!.contains! "source code of Rubylog"
+  "spec".dir!.contains! "functional tests written in RSpec"
+  "logic".dir!.contains! "integration tests written in Rubylog"
+
+  gitignore = File.readlines(".gitignore").map{|l| l.chop}
+  check X.in(Y.dir.map{Y}).iff(X.in(Y.dirname_in(".").and(Y.not_in(gitignore)).map{Y}))
+
+end
+

data/logic/dsl_logic.rb

@@ -0,0 +1,29 @@
+theory do
+
+  # prefix functors
+
+  prefix_functor :we_have
+  we_have! :weapons
+  we_have! :sunglasses
+  we_have! :rustling_leather_coats
+
+  check we_have :sunglasses
+  check { we_have? :rustling_leather_coats }
+
+  
+  # built-in prefix functors
+  
+  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 } }
+
+  # variables
+  check A.is(ANY).and{ A == nil }
+  check A.is(4)  .and{ A == 4 }
+  check B.is(4)  .and{ A.is_a? Rubylog::Variable }
+  check B.is(ANY).and{ A.is_a? Rubylog::Variable }
+
+end

data/logic/errors_logic.rb

@@ -0,0 +1,9 @@
+theory do
+  functor_for String, :happy, :has
+
+  # syntax error
+  check { begin "John".happy.if; rescue Rubylog::SyntaxError; true else false end }
+  check { begin "John".happy.if!; rescue Rubylog::SyntaxError; true else false end }
+  check { begin "John".happy.unless; rescue Rubylog::SyntaxError; true else false end }
+
+end

data/logic/guard_logic.rb

@@ -0,0 +1,115 @@
+theory do
+  
+  # class guard
+  functor_for Numeric, :divides
+  A[Integer].divides(B[Integer]).if { B % A == 0 }
+  A[Float].divides!(B[Float])
+  check 2.divides(10)
+  check 2.divides(9).false
+  check 2.divides(1).false
+  check 2.divides(0)
+  check 2.12.divides(4.5)
+  check -0.31.divides(-1.5)
+  check 0.3.divides(3).false
+  check 2.0.divides(10).false
+  check 2.divides(10.0).false
+  check 2.divides(9.0).false
+
+  # union of guards at compile
+  functor_for Numeric, :small
+  A[0...100].small.if ANY.is A[Integer]
+  check 0.small
+  check 10.small
+  check -1.small.false
+  check 0.0.small.false
+  check 99.small
+  check 99.0.small.false
+  check 99.9.small.false
+  check 100.small.false
+  check 100.0.small.false
+
+  # union of guards at compile (dont-care)
+  functor_for Numeric, :small
+  A[0...100].small.if A.is ANY[Integer]
+  check 0.small
+  check 10.small
+  check -1.small.false
+  check 0.0.small.false
+  check 99.small
+  check 99.0.small.false
+  check 99.9.small.false
+  check 100.small.false
+  check 100.0.small.false
+  
+  # union of guards at unification
+  self[[:small,1]].clear
+  functor_for Numeric, :small
+  A[0...100].small.if A.is B[Integer]
+  check 0.small
+  check 10.small
+  check -1.small.false
+  check 0.0.small.false
+  check 99.small
+  check 99.0.small.false
+  check 99.9.small.false
+  check 100.small.false
+  check 100.0.small.false
+
+  # union of guards at unification (reversed)
+  self[[:small,1]].clear
+  functor_for Numeric, :small
+  A[0...100].small.if B[Integer].is A
+  check 0.small
+  check 10.small
+  check -1.small.false
+  check 0.0.small.false
+  check 99.small
+  check 99.0.small.false
+  check 99.9.small.false
+  check 100.small.false
+  check 100.0.small.false
+
+
+  # proc guards
+  functor_for Numeric, :big
+  A[proc{|a|a > 20}].big!
+  check -100.big.false
+  check 0.big.false
+  check 10.big.false
+  check 20.big.false
+  check 21.big
+  check 200.big
+
+  # hash guards
+  functor_for String, :char
+  S[length: 1].char!
+  check "a".char
+  check " ".char
+  check "".char.false
+  check "af".char.false
+  check "Hello".char.false
+
+  # list hash guards
+  functor_for String, :capitalized
+  S[[:[],0] => /[A-Z]/].capitalized!
+  check "a".capitalized.false
+  check " ".capitalized.false
+  check "".capitalized.false
+  check "af".capitalized.false
+  check "A".capitalized
+  check "Hello".capitalized
+
+
+  # chained hash guards
+  functor_for String, :funny
+  S[upcase: {[:[],1..-2] => "ELL"}].funny!
+  check "hello".funny
+  check "Bell!".funny
+  check "BELL!".funny
+  check "DELL".funny.false
+  check "help!".funny.false
+  check "hello!".funny.false
+
+
+
+end

data/logic/list_logic.rb

@@ -0,0 +1,55 @@
+theory do
+  check [1,2,3].is [1,2,3]
+  check {[1,2,3].is([A,B,C]).map{[A,B,C]} == [[1,2,3]]}
+  check [].is []
+
+  check [1,2,3].is_not [1,2,4]
+  check [1,2,3].is_not [1,2]
+  check [1,2,3].is_not [1,ANY]
+  check [1,2,3].is [1,2,ANY]
+
+  # splats
+  check { [1,2,3].is([1,*A]).map{A} == [[2,3]] }
+  check [].is_not [A,*ANY]
+  check [].is [*ANY]
+  check [2].is [2, *ANY]
+  check [2, *ANY].is [2]
+  check [1,2].is([A,*B]).and A.is(1).and B.is([2])
+
+  # [*A] = [*B]
+  check {[*A].is([*B]).and A.is([1,2]).map{B} == [[1,2]]}
+  check [*A].is [*B]
+  check { [*A].is([*B]).each { } } # no infinite recursion
+
+
+  # append
+  check {[1,2,3].is([*A,*B]).map{[A,B]} == [[[],[1,2,3]],[[1],[2,3]],[[1,2],[3]],[[1,2,3],[]]] }
+  check [1,2,3].is [Rubylog::DSL::ArraySplat.new([1,2]),*ANY]
+  check [1,2,3].is [Rubylog::DSL::ArraySplat.new([1,2,3]),*ANY]
+  check [1,2,3].is_not [Rubylog::DSL::ArraySplat.new([1,2,3,B]),*ANY]
+  
+  # member
+  check [1,2,3].is [*ANY,2,*ANY]
+  check X.is([1,2,3]).and A.in(X).all X.is [*ANY,A,*ANY]
+
+  # palindromes
+  functor_for Array, :palindrome
+  [].palindrome!
+  [ANY].palindrome!
+  [A,*X,A].palindrome.if X.palindrome
+  check X.in([[], [1], [1,1], [1,2,1], [1,2,2,1], [1,2,3,2,1], [1,2,3,3,2,1]]).all X.palindrome
+  check X.in([[1,2], [1,3,4,1], [2,2,5]]).none X.palindrome
+
+  # legacy syntax
+  check { [1,2,3].is([1]+A).map{A} == [[2,3]] }
+  check [].is_not [A]+ANY
+  check [].is []+ANY
+  check [2].is [2]+ANY
+  check(([2]+ANY).is [2])
+  check [1,2].is([A]+B).and A.is(1).and B.is([2])
+  check {([]+A).is([]+B).and A.is([1,2]).map{B} == [[1,2]]}
+  check(([]+A).is([]+B))
+  check {([]+A).is([]+B).each { } }
+  check {[1,2,3].is([]+A+B).map{[A,B]} == [[[],[1,2,3]],[[1],[2,3]],[[1,2],[3]],[[1,2,3],[]]] }
+  check X.is([1,2,3]).and A.in(X).all X.is []+ANY+[A]+ANY
+end

data/logic/map_logic.rb

@@ -0,0 +1,15 @@
+theory "Rubylog::MapLogic" do
+  functor :likes
+  subject Symbol
+
+  # inriausite^findall
+  check S.is{X.is(1).or(X.is(2)).map{X}}.and{S == [1,2]}
+  check S.is{X.is(:john).map{X.likes(Y)}}.and{S == [:john.likes(Y)]}
+  check G.is(:fail.or :fail).and L.is{G.map{X}}.and{L == []}
+  check S.is{X.is(1).or(X.is(1)).map{X}}.and{S == [1,1]}
+  check [1,2].is{X.is(2).or(X.is(1)).map{X}}.false
+  check [X,Y].is{A.is(1).or(A.is(2)).map{A}}.and{X == 1}.and{Y == 2}
+  (S.is {Goal.map{X}}).solve and check :fail rescue NoMethodError
+  (S.is {4.map{X}}).solve and check :fail rescue NoMethodError
+end
+

data/logic/multitheory.rb

@@ -0,0 +1,23 @@
+load "lib/rubylog/theory.rb"
+A = theory do
+  functor_for Symbol, :good
+
+  :x.good!
+end
+
+B = theory do
+  :y.good!
+end
+
+theory do
+  multitheory [:good,1]
+
+  check { self[[:good,1]].multitheory? }
+
+  include A
+  include B
+
+  check { self[[:good,1]].multitheory? }
+
+  check {X.good.map{X} == [:x,:y]}
+end

data/logic/recursion_logic.rb

@@ -0,0 +1,12 @@
+theory do
+  functor_for Integer, :factorial 
+  0.factorial! 1
+  N.factorial(K).if proc{N > 0}.and 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/logic/string_logic.rb

@@ -0,0 +1,41 @@
+theory do
+  check "asdf".is "asdf"
+  check { "abc#{S}def" =~ /abc.S\[\].def/ }
+  check { "abc#{S[length: 1]}def" =~ /abc.S\[\d+\].def/ }
+  check { "h#{S}o".is("hello").map{S} == ["ell"] }
+  check { "#{Base}.#{Ext}".is("hello.rb").map{Base} == ["hello"] }
+  
+  check { "#{Base}.#{Ext}".is("hello.rb").map{Ext} == ["rb"] }
+  check { "h#{S}o".is("auto").map{S} == [] }
+
+  # backtracked matches
+  check { "abc".is("#{A}#{B}").map{"#{A}:#{B}"} == [":abc","a:bc","ab:c","abc:"] }
+  check { "www.google.com".is("#{A}.#{B}").map{[A,B]} == [["www", "google.com"],["www.google", "com"]] }
+  check { "a".is("#{A}#{B}#{C}").map{"#{A}:#{B}:#{C}"} == ["::a",":a:","a::"] }
+  check { "ab".is("#{A}#{B}#{C}").map{"#{A}:#{B}:#{C}"} == %w(::ab :a:b :ab: a::b a:b: ab::) }
+
+  # guards
+  check { "abc".is("#{A[/\A.\z/]}#{B}").map{"#{A}:#{B}"} == ["a:bc"] }
+  check { "abc".is("#{A[length: 1]}#{B}").map{"#{A}:#{B}"} == ["a:bc"] }
+
+
+  # palindromes
+  functor_for String, :palindrome
+
+  S[empty?: true].palindrome!
+  S[length: 1].palindrome!
+  S[lambda{|s|s.length > 1}].palindrome.if S.is("#{A[length: 1]}#{B}#{A}").and B.palindrome
+
+  check "".palindrome
+  check "dd".palindrome
+  check "aba".palindrome
+  check "faaf".palindrome
+  check "ffaaff".palindrome
+  check "rererer".palindrome
+  check "lol".palindrome
+  check "ji".palindrome.false
+  check "doo".palindrome.false
+  check "taaaz".palindrome.false
+  check "faad".palindrome.false
+  check "rerere".palindrome.false
+end

data/logic/thats_logic.rb

@@ -0,0 +1,51 @@
+require "./lib/rubylog/builtins/file_system"
+
+theory do
+  functor_for Integer, :factorial
+
+  # one level
+  check 4.is(ANY[Integer,thats < 10])
+  check 4.is(ANY[Integer,thats < 5])
+  check 4.is(ANY[Integer,thats < 4]).false
+  check 4.is(ANY[Integer,thats < 2]).false
+
+  # question mark
+  check "".is(ANY[thats.empty?])
+  check "a".is(ANY[thats.empty?]).false
+
+  # two levels
+  check "hello".is(ANYTHING[thats.reverse == "olleh"])
+  check "hello".is(ANYTHING[thats.reverse == "olle"]).false
+
+  # four levels
+  check "hello".is(ANY[thats.upcase.partition("E")[0] == "H"])
+  check "hello".is(ANY[thats.upcase.partition("E")[1] == "E"])
+  check "hello".is(ANY[thats.upcase.partition("E")[2] == "LLO"])
+  check "hello".is(ANY[thats.upcase.partition("E")[1] == "H"]).false
+  check "hello".is(ANY[thats.upcase.partition("E")[0] == "h"]).false
+  check "hello".is(ANY[thats.upcase.partition("L")[0] == "H"]).false
+  check "hello".is(ANY[thats.upcase.partition("e")[0] == "H"]).false
+
+  # files
+  check {     "#{S[String, thats.start_with?(".")]}".filename_in(".").map{S}.include? ".gitignore" }
+  check { not "#{S[String, thats.start_with?(".")]}".filename_in(".").map{S}.include? "lib" }
+  check { "#{S[/\A(.*)\.rb/]}".filename_in("lib").map{S} == ["rubylog.rb"] }
+
+  # factorial
+  0.factorial! 1
+  K[thats > 0].factorial(N).if K0.is{K-1}.and K0.factorial(N0).and N.is{N0*K}
+
+  # palindrome
+  functor_for String, :palindrome 
+  S[String, thats.length <= 1].palindrome!
+  "#{A[thats.length == 1]}#{B}#{A}".palindrome.if B.palindrome
+
+  check "a".palindrome
+  check "aa".palindrome
+  check "aga".palindrome
+  check "aaa".palindrome
+  check "avava".palindrome
+  check "ab".palindrome.false
+  check "abb".palindrome.false
+  check "abab".palindrome.false
+end

data/logic/variable_logic.rb

@@ -0,0 +1,24 @@
+theory do
+  # dont-care variables case insensitive ANY* and _*
+  check 3.is(ANY).and 3.is(ANY)
+  check 3.is(ANY).and 4.is(ANY)
+  check 3.is(ANYTHING).and 3.is(ANYTHING)
+  check 3.is(ANYTHING).and 4.is(ANYTHING)
+  check 3.is(Anything).and 3.is(Anything)
+  check 3.is(Anything).and 4.is(Anything)
+  check 3.is(Rubylog::Variable.new(:_var1)).and(3.is(Rubylog::Variable.new(:_var1)))
+  check 3.is(Rubylog::Variable.new(:_var1)).and(4.is(Rubylog::Variable.new(:_var1)))
+  check 3.is(Rubylog::Variable.new(:var1 )).and(3.is(Rubylog::Variable.new(:var1 )))
+  check 3.is(Rubylog::Variable.new(:var1 )).and(4.is(Rubylog::Variable.new(:var1 ))).false
+
+  # dont-care variables support recursion
+  functor_for Integer, :factorial 
+  0.factorial! 1
+  N.factorial(K).if proc{N > 0}.and N1.is {N-1} .and N1.factorial(K1).and K.is{ N*K1 }.and K.is(ANY1).and N.is(ANY2)
+  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