rubylog 1.0.0 → 2.0pre1

data/Gemfile

@@ -1,18 +1,9 @@
 source "http://rubygems.org"
-# Add dependencies required to use your gem here.
-# Example:
-#   gem "activesupport", ">= 2.3.5"
 
-# Add dependencies to develop your gem here.
-# Include everything needed to run rake, tests, features, etc.
 group :development do
-  gem "rspec", "~> 2.8.0"
+  gem "rspec", ">= 2.8.0", " < 3"
   gem "yard", "~> 0.7"
-  gem "rdoc", "~> 3.12"
-  gem "cucumber", ">= 0"
-  gem "bundler", "~> 1.0.0"
-  gem "jeweler", "~> 1.8.3"
+  gem "bundler", ">= 1.0.0"
+  gem "jeweler", ">= 1.8.3"
   gem "simplecov", :require => false
-  gem "reek", "~> 1.2.8"
-  gem "roodi", "~> 2.1.0"
 end

data/Gemfile.lock

@@ -1,64 +1,38 @@
 GEM
   remote: http://rubygems.org/
   specs:
-    builder (3.0.0)
-    cucumber (1.1.4)
-      builder (>= 2.1.2)
-      diff-lcs (>= 1.1.2)
-      gherkin (~> 2.7.1)
-      json (>= 1.4.6)
-      term-ansicolor (>= 1.0.6)
-    diff-lcs (1.1.3)
-    gherkin (2.7.6)
-      json (>= 1.4.6)
+    diff-lcs (1.2.4)
     git (1.2.5)
-    jeweler (1.8.3)
+    jeweler (1.8.4)
       bundler (~> 1.0)
       git (>= 1.2.5)
       rake
       rdoc
-    json (1.6.5)
-    multi_json (1.0.4)
-    rake (0.9.2.2)
-    rdoc (3.12)
+    json (1.7.7)
+    multi_json (1.7.2)
+    rake (10.0.4)
+    rdoc (4.0.1)
       json (~> 1.4)
-    reek (1.2.8)
-      ruby2ruby (~> 1.2)
-      ruby_parser (~> 2.0)
-      sexp_processor (~> 3.0)
-    roodi (2.1.0)
-      ruby_parser
-    rspec (2.8.0)
-      rspec-core (~> 2.8.0)
-      rspec-expectations (~> 2.8.0)
-      rspec-mocks (~> 2.8.0)
-    rspec-core (2.8.0)
-    rspec-expectations (2.8.0)
-      diff-lcs (~> 1.1.2)
-    rspec-mocks (2.8.0)
-    ruby2ruby (1.3.1)
-      ruby_parser (~> 2.0)
-      sexp_processor (~> 3.0)
-    ruby_parser (2.3.1)
-      sexp_processor (~> 3.0)
-    sexp_processor (3.0.10)
-    simplecov (0.5.4)
-      multi_json (~> 1.0.3)
-      simplecov-html (~> 0.5.3)
-    simplecov-html (0.5.3)
-    term-ansicolor (1.0.7)
-    yard (0.7.5)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.1)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.13.1)
+    simplecov (0.7.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.7.1)
+    simplecov-html (0.7.1)
+    yard (0.8.6.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.0.0)
-  cucumber
-  jeweler (~> 1.8.3)
-  rdoc (~> 3.12)
-  reek (~> 1.2.8)
-  roodi (~> 2.1.0)
-  rspec (~> 2.8.0)
+  bundler (>= 1.0.0)
+  jeweler (>= 1.8.3)
+  rspec (>= 2.8.0, < 3)
   simplecov
   yard (~> 0.7)

data/README.rdoc

@@ -5,6 +5,8 @@ Buck}[http://weblog.jamisbuck.org/2006/10/28/prolog-in-ruby], and the
 implementation is based on {Yield Prolog}[http://yieldprolog.sourceforge.net/],
 with lots of sintactic and semantic additions.
 
+See the {wiki}[https://github.com/cie/rubylog/wiki] for online documentation.
+
 == Getting started
 
 First, install the gem
@@ -13,19 +15,14 @@ First, install the gem
 
 or, if you use +bundler+, add this line to your +Gemfile+:
 
-  gem 'rubylog', '~>1.0.0'
+  gem 'rubylog', '~>2.0pre1'
 
 
 
-First, you have to create a theory and write your code in the block given to it:
+First, you need a Rubylog context. The simplest you can do is to extend Rubylog::Context into the main object.
 
   require 'rubylog'
-
-  MyTheory = theory do
-    # your code here
-  end
-
-All further examples in this file should be written within the +theory+ block.
+  extend Rubylog::Context
 
 
 === Data types
@@ -40,13 +37,6 @@ Rubylog variables are (undefined) constant names:
 A variables whose name starts with +ANY...+ (case-insensitive) is a don't-care
 variable (like +_+ in Prolog).
 
-Structures are in a different order than they are in prolog:
-
-  functor_for String, :likes
-  'John'.likes('beer')
-
-which would be +likes('John','beer')+ in prolog.
-
 Lists are just Ruby arrays:
 
   [1, 2, 3]
@@ -55,28 +45,36 @@ They can have splats:
 
   [1, 2, *T]
 
-Which would be +[1,2|T]+ in Prolog, however, in Rubylog, splats are not limited
+Which would be <tt>[1,2|T]</tt> in Prolog, however, in Rubylog, splats are not limited
 to the end.
 
 === Predicates
+As in prolog, predicates are the buinding blocks of your program. However, the arguments are in a different order than they are in prolog:
+
+  predicate_for String, ".likes()"
+  'John'.likes!('beer')
+
+which would be <tt>likes('John','beer').</tt> in prolog. In Rubylog, predicates must be declared. The string indicating the predicate syntax is <tt>".likes()"</tt>. The format is <tt>:asdf .asdf .asdf() .asdf(,) .asdf(,,)</tt> for predicates with 0,1,2,3,4 arguments.
 
 You can assert a rule with the +if+ method:
 
+  predicate_for String, ".drinks() .has()"
   X.drinks(Y).if X.has(Y).and X.likes(Y)        
 
 This would be +drinks(X,Y) :- has(X,Y), likes(X,Y)+ in Prolog.
 
-You can assert facts with +if(:true)+, or, as a shorthand you can use the bang
+You can assert facts with <tt>if(:true)</tt>, or, as a shorthand you can use the bang
 syntax:
 
   'John'.likes! 'milk'                         
 
-Bang assertions return their first argument (which is +'John'+ in this case), so they can be chained:
+Bang assertions return their first argument (which is <tt>'John'</tt> in this case), so they can be chained:
 
   'John'.likes!('beer').has!('beer')
 
 You can also use +unless+:
 
+  predicate_for String, ".good .bad"
   A.good.unless A.bad              
 
 Nullary predicates are symbols, similar to Prolog:
@@ -93,17 +91,22 @@ Some built-in predicates and their Prolog equivalents:
   -------  ------ 
   :true     true
   :fail     fail
-  .and      ,
-  .or       ;
+  .and()    ,
+  .or()     ;
   :false    \+
-  .is       =
-  .is_not   =/=
-  .in       member
+  .is()     =
+  .is_not() =/=
+  .in()     member
   :cut!     !
 
 There are some new ones:
 
-  is_not, not_in, all, any, one, none, iff
+  not_in, all, any, one, none, iff
+
+You can see reference of these in <tt>lib/rubylog/builtins/logic.rb</tt> and <tt>lib/rubylog/builtins/term.rb</tt>
+
+
+See the documentation in <tt>lib/rubylog/builtins/</tt>
 
 === Unification
 
@@ -180,23 +183,24 @@ variables are substituted with their respecitve value (or +nil+ if they are not
 bound).
 
 All built-in rubylog predicates are clean logical programming predicates witout
-a side-effect. If you want some side-effect, you always go into native mode.
+a side-effect. If you want some side-effects, you always go into native mode.
 
 === Rubylog as a test suite
 
 You can write simple tests using the +check+ method:
 
   theory do
-    check :true
+    check :true.or :false
+    check A.is(3).and A.in [1,2,3]
     check { 5+5 == 10 }
   end
 
-You sould put this file in +"./logic/something\_logic.rb"+. Then you can run it
+You sould put this file in <tt>"./logic/something\_logic.rb"</tt>. Then you can run it
 with 
 
   rubylog logic/something_logic.rb
 
-Or you can run all files in +logic/**/*_logic.rb+ with
+Or you can run all files in <tt>logic/**/*\_logic.rb</tt> with
 
   rubylog
 
@@ -240,18 +244,14 @@ You can make some metaprogramming with Rubylog
 == Contributing
 
 === To the language
-* Create an issue on the {issue tracker}[https://github.com/cie/rubylog/issues].
-* We will discuss it.
-* Maybe I'll introduce it.
 
-=== To the implementation
+* Post your own examples to the {wiki}[https://github.com/cie/rubylog/wiki/Examples].
+* Improve others' examples.
+* If you have a suggestion for the language, submit an issue.
+
+=== Reporting bugs or requesting features
+
 * Create an issue on the {issue tracker}[https://github.com/cie/rubylog/issues].
-* We will discuss it.
-* Maybe I'll implement it.
-* If not, fork the project.
-* Implement it.
-* Have fun.
-* Post a pull request.
 
 == Copyright
 

data/README.rdoc.orig

@@ -0,0 +1,284 @@
+= Rubylog - Prolog interpreter for ruby
+
+Rubylog is a Prolog-like DSL for Ruby. The language is inspired by {Jamis
+Buck}[http://weblog.jamisbuck.org/2006/10/28/prolog-in-ruby], and the
+implementation is based on {Yield Prolog}[http://yieldprolog.sourceforge.net/],
+with lots of sintactic and semantic additions.
+
+See the {wiki}[https://github.com/cie/rubylog/wiki] for online documentation.
+
+== Getting started
+
+First, install the gem
+
+  $ gem install rubylog
+
+or, if you use +bundler+, add this line to your +Gemfile+:
+
+  gem 'rubylog', '~>2.0pre1'
+
+
+
+First, you need a Rubylog context. The simplest you can do is to extend Rubylog::Context into the main object.
+
+  require 'rubylog'
+  extend Rubylog::Context
+
+
+=== Data types
+
+Rubylog is similar to Prolog, but there are quite a few differences. In Rubylog,
+you can use any Ruby object as data.
+
+Rubylog variables are (undefined) constant names:
+
+  A, B, ANYTHING
+
+A variables whose name starts with +ANY...+ (case-insensitive) is a don't-care
+variable (like +_+ in Prolog).
+
+<<<<<<< HEAD
+Structures are in a different order than they are in prolog:
+
+  functor_for String, :likes
+  'John'.likes('beer')
+
+which would be <tt>likes('John','beer')</tt> in prolog.
+
+=======
+>>>>>>> develop
+Lists are just Ruby arrays:
+
+  [1, 2, 3]
+
+They can have splats:
+
+  [1, 2, *T]
+
+Which would be <tt>[1,2|T]</tt> in Prolog, however, in Rubylog, splats are not limited
+to the end.
+
+=== Predicates
+As in prolog, predicates are the buinding blocks of your program. However, the arguments are in a different order than they are in prolog:
+
+  predicate_for String, ".likes()"
+  'John'.likes!('beer')
+
+which would be <tt>likes('John','beer').</tt> in prolog. In Rubylog, predicates must be declared. The string indicating the predicate syntax is <tt>".likes()"</tt>. The format is <tt>:asdf .asdf .asdf() .asdf(,) .asdf(,,)</tt> for predicates with 0,1,2,3,4 arguments.
+
+You can assert a rule with the +if+ method:
+
+  predicate_for String, ".drinks() .has()"
+  X.drinks(Y).if X.has(Y).and X.likes(Y)        
+
+This would be +drinks(X,Y) :- has(X,Y), likes(X,Y)+ in Prolog.
+
+You can assert facts with <tt>if(:true)</tt>, or, as a shorthand you can use the bang
+syntax:
+
+  'John'.likes! 'milk'                         
+
+Bang assertions return their first argument (which is <tt>'John'</tt> in this case), so they can be chained:
+
+  'John'.likes!('beer').has!('beer')
+
+You can also use +unless+:
+
+  predicate_for String, ".good .bad"
+  A.good.unless A.bad              
+
+Nullary predicates are symbols, similar to Prolog:
+
+  'John'.drinks('beer').if :false.and(:cut!).or(:true)
+
+
+
+=== Built-in predicates
+
+Some built-in predicates and their Prolog equivalents:
+
+<<<<<<< HEAD
+  Prolog     Rubylog  
+  ------     -------  
+   true/0    :true    
+   fail/0    :fail    
+   ','/2     .and()
+   ';'/2     .or()
+   '\+'/1    .false   
+   '='/2     .is()      
+   '=/='/2   .is_not()  
+   member/2  .in()      
+   '!'/0     :cut!    
+=======
+  Rubylog  Prolog
+  -------  ------ 
+  :true     true
+  :fail     fail
+  .and()    ,
+  .or()     ;
+  :false    \+
+  .is()     =
+  .is_not() =/=
+  .in()     member
+  :cut!     !
+>>>>>>> develop
+
+There are some new ones:
+
+  not_in, all, any, one, none, iff
+
+You can see reference of these in <tt>lib/rubylog/builtins/logic.rb</tt> and <tt>lib/rubylog/builtins/term.rb</tt>
+
+
+See the documentation in <tt>lib/rubylog/builtins/</tt>
+
+=== Unification
+
+In Rubylog, unification works quite the same in Prolog, with the +is+ functor.
+
+  A.is(B)
+
+Using arrays, you can benefit the splats:
+
+  [1,2,3,4].is([A,B,*T])      # [1,2,3,4] = [A,B|T]     in prolog
+  [1,2,3,4].is([*H,*T])       # append(H, T, [1,2,3,4]) in prolog
+
+The +in+ predicate unifies the first argument with any member of the collection:
+
+  4.in([1,2,3,4])
+
+You can use guards:
+
+  A[String].in(["asdf",5,nil]).each { p A }   # outputs "asdf"
+  A[/x/].in(["asdf","xyz"]).each { p A }      # outputs "xyz"
+  A[thats < 5].in([4,5,6]).each { p A }       # outputs 4
+
+=== Moving between Ruby and Rubylog
+==== Running a query
+
+If you want to run a query, you have many different syntaxes:
+
+  prove ('John'.drinks 'beer')  # => true
+  true? ('John'.drinks 'beer')  # => true
+  ('John'.drinks 'beer').true?  # => true
+  'John'.drinks? 'beer'         # => true
+
+==== Enumerations
+
++Structure+ implements +Enumerable+, and yields the solutions. Within the
+enumeration block, you can access the values of your variables.
+
+  'John'.drinks! 'beer'
+  ('John'.drinks X).each {p X}      # outputs 'beer'
+  ('John'.drinks X).map{X}          # => ['beer']
+  ('John'.drinks X).count           # => 1
+
+==== Procs as predicates
+
+You can invoke Ruby codes in Rubylog rules with a proc:
+
+  'John'.likes(Y).if proc{ Y =~ /ale/ }
+
+or in most cases you can use just a block:
+
+  'John'.likes(Y).if { Y =~ /ale/ }
+
+The predicate succeeds if the block returns a true value.
+
+==== Procs as functions
+
++is+ and +in+ can take a proc or block argument, which they execute and take its return value:
+
+  X.good.if X.is { 'BEER'.downcase }
+  X.good.if X.in { get_good_drinks() }
+
+==== The two modes of Rubylog
+
+Rubylog has two modes, DSL and native. DSL code is executed only once
+at compile time, and is used for describing the Rubylog program. Native code is
+executed runtime. Any block passed to Rubylog structures native code.
+
+  ('John'.drinks X).and { X != 'beer'}.each { p X }
+  ^^^^^^^^^^^^^^^^^^^^^^              ^^^^^^          dsl mode
+                         ^^^^^^^^^^^^        ^^^^^    native mode
+
+In dsl mode, variables are +Rubylog::Variable+ objects. In native mode,
+variables are substituted with their respecitve value (or +nil+ if they are not
+bound).
+
+All built-in rubylog predicates are clean logical programming predicates witout
+a side-effect. If you want some side-effects, you always go into native mode.
+
+=== Rubylog as a test suite
+
+You can write simple tests using the +check+ method:
+
+  theory do
+    check :true.or :false
+    check A.is(3).and A.in [1,2,3]
+    check { 5+5 == 10 }
+  end
+
+You sould put this file in <tt>"./logic/something\_logic.rb"</tt>. Then you can run it
+with 
+
+  rubylog logic/something_logic.rb
+
+Or you can run all files in <tt>logic/**/*\_logic.rb</tt> with
+
+  rubylog
+
+=== Other built-in libraries
+
+==== File system
+
+You can make some queries on the file system:
+
+  require "rubylog/builtins/file_system"
+
+  theory do
+    check "README".filename_in "."
+
+    X.dirname_in(".").each { puts X }
+  end
+
+
+==== Reflection
+
+You can make some metaprogramming with Rubylog
+
+
+  require "rubylog/builtins/reflection"
+
+  theory do
+    functor_for String, :likes
+
+    check "John".likes("Jane").structure(:likes, ["John", "Jane"])
+
+    "John".likes(X).if X.likes("John")
+    "Jane".likes!("John")
+    check "John".likes("Jane").follows_from "Jane".likes("John")
+
+    "John".likes!("milk")
+    check "John".likes("milk").fact
+    check "John".likes("beer").fact.false
+
+  end
+
+== Contributing
+
+=== To the language
+
+* Post your own examples to the {wiki}[https://github.com/cie/rubylog/wiki/Examples].
+* Improve others' examples.
+* If you have a suggestion for the language, submit an issue.
+
+=== Reporting bugs or requesting features
+
+* Create an issue on the {issue tracker}[https://github.com/cie/rubylog/issues].
+
+== Copyright
+
+Copyright (c) 2013 Bernát Kalló. See LICENSE.txt for
+further details.
+

data/RELEASE_NOTES.rdoc

@@ -0,0 +1,51 @@
+== Version 2.1 (planned)
+* New features
+  * solve without a block returns an enumerator
+  * warning for singleton variables
+  * predicate for checking bound/unbound variables
+
+== Version 2.0.0 (to be released)
+* Backwards incompatibilities
+  * <tt>Rubylog.theory</tt> is removed. Use <tt>Kernel#Rubylog</tt>.
+  * <tt>file\_in</tt> includes directories and yields relative paths.
+    <tt>dir\_in</tt> also yields relative paths.
+  * <tt>trace</tt> has became <tt>Rubylog.trace</tt>. If you use
+    <tt>Kernel#Rubylog</tt>, it does not matter.
+  * <tt>Theory</tt> has changed to <tt>Context</tt> and it became a module. 
+  * No more inclusion of theories (contexts).
+  * Predicates do not have reference in the theory (context), they are only referenced from the
+    subject class in closures of the functor methods.
+  * Unification uses <tt>eql?</tt> instead of <tt>==</tt>. This means
+    <tt>5.0.is\_not(5)</tt>
+  * <tt>Theory#eval</tt> removed. Use <tt>Context#instance\_eval</tt>.
+  * Removed <tt>functor</tt>, use <tt>predicate</tt> and <tt>predicate\_for</tt>
+    instead. The latter ones have a different syntax for indicating predicates, eg.
+    <tt>".and() .false :true"</tt> or <tt>"L.splits\_to(H,T)"</tt>
+  * <tt>Structure</tt> is bound to the predicate it represents. The first argument of <tt>Structure.new</tt> is the predicate. <tt>S.structure(Predicate,Functor,Args)</tt> now has 4 arguments.
+  * <tt>current\_theory</tt> is removed.
+  * No more real prefix functors, n-ary prefix functors are n\+1-ary functors with the context object as the first argument. Use <tt>predicate\_for Rubylog::Context, "..."</tt>.
+  * <tt>Rubylog::DefaultBuiltins</tt> is replaced by <tt>Rubylog</tt>
+  * <tt>Theory#prove</tt> was removed. Use <tt>Context#true?</tt>
+  * <tt>Rubylog::Callable<tt> renamed to <tt>Rubylog::Clause</tt>
+  * <tt>discontiguous</tt> is removed. No more discontiguity checks.
+  * <tt>implicit</tt> is removed. No implicit mode anymore.
+  * <tt>Theory#clear</tt> is replaced by <tt>Context#initialize\_context</tt>.
+    However, currently it only clears <tt>default\_subject</tt>.
+  * <tt>CompositeTerm</tt> is renamed to <tt>CompoundTerm</tt>.
+  * <tt>rublog\_compile\_variables</tt> is renamed to
+     <tt>rubylog\_match\_variables</tt>, <tt>variable\_hashes</tt> is removed.
+  * <tt>rubylog\_variables\_hash</tt> removed
+* Features 
+  * Rspec integration
+  * +include+ or +extend+ <tt>Rubylog::Context</tt> into any class or object
+  * thats\_not
+  * Comments in indicators
+  * New tracer
+  * added <tt>every</tt>
+  * all builtins are available by default
+* Bug fixes
+
+
+== Version 1.0.0
+== Version 0.0.1
+== Version 0.0.0

data/Rakefile

@@ -11,14 +11,16 @@ rescue Bundler::BundlerError => e
 end
 require 'rake'
 
+# Jeweler - gem manager
 require 'jeweler'
 Jeweler::Tasks.new do |gem|
   # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
   gem.name = "rubylog"
+  gem.version = File.open("VERSION"){|f|f.readline.strip}
   gem.homepage = "https://github.com/cie/rubylog"
   gem.license = "MIT"
-  gem.summary = %Q{An embedded Prolog interpreter}
-  gem.description = %Q{Rubylog is an embedded Prolog language and interpreter for Ruby.}
+  gem.summary = %Q{A Prolog-like DSL}
+  gem.description = %Q{Rubylog is a Prolog-like DSL for Ruby.}
   gem.email = "kallo.bernat@gmail.com"
   gem.authors = ["Bernát Kalló"]
   gem.executables = Dir["bin/*"].map{|x|File.basename x}
@@ -26,33 +28,27 @@ Jeweler::Tasks.new do |gem|
 end
 Jeweler::RubygemsDotOrgTasks.new
 
+# RSpec - for tests
 require 'rspec/core'
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.pattern = FileList['spec/**/*_spec.rb']
 end
 
-require 'cucumber/rake/task'
-Cucumber::Rake::Task.new(:features)
+require 'yard'
+YARD::Rake::YardocTask.new
 
-require 'reek/rake/task'
-Reek::Rake::Task.new do |t|
-  t.fail_on_error = true
-  t.verbose = false
-  t.source_files = 'lib/**/*.rb'
+file "doc/models.dot" do |f|
+  sh "yard graph > #{f.name}"
 end
 
-require 'roodi'
-require 'roodi_task'
-RoodiTask.new do |t|
-  t.verbose = false
+rule ".svg" => ".dot" do |f|
+  sh "fdp #{f.source} -Tsvg > #{f.name}"
 end
 
-task :logic do
-  run "ruby"
+task :yardserver do
+  sh "yard server --reload"
 end
 
-task :default => :logic
 
-require 'yard'
-YARD::Rake::YardocTask.new
+

data/VERSION

@@ -1 +1 @@
-1.0.0
+2.0pre1

data/examples/a_plus_b.rb

@@ -0,0 +1,6 @@
+require "rubylog"
+extend Rubylog::Context
+
+"#{A} #{B}".in{$stdin.readlines}.each do
+  puts A.to_i + B.to_i
+end