rubylog 0.0.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,18 @@
+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 "yard", "~> 0.7"
+  gem "rdoc", "~> 3.12"
+  gem "cucumber", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.8.3"
+  gem "simplecov"
+  gem "reek", "~> 1.2.8"
+  gem "roodi", "~> 2.1.0"
+end

data/Gemfile.lock

@@ -0,0 +1,64 @@
+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)
+    git (1.2.5)
+    jeweler (1.8.3)
+      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.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)
+
+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)
+  simplecov
+  yard (~> 0.7)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Bernát Kalló
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,96 @@
+= Rubylog - Prolog interpreter for ruby
+
+Rubylog is an implementation of (part of) the Prolog language as a Ruby DSL. The DSL 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/].
+
+== Installing
+  $ gem install rubylog
+
+== Using
+
+To get started you have to do three things: require rubylog, include +Rubylog::DSL::Constants+ and declare some functors on a class you want to use:
+  require 'rubylog'
+  include Rubylog::DSL::Constants
+  Symbol.rubylog_functor :likes, :drinks, :has
+
+A Rubylog clause can be created by sending the functor to the first argument, passing the other arguments:
+  :John.likes :beer       # likes(john,beer) in Prolog
+
+A variable is an undefined constant. Don't-care variables start with ANY...
+  A, B, Cat               # the same in Prolog
+  ANY, ANYONE, ANYTHING   # _ in Prolog
+
+Now you can start writing Rubylog predicates. Facts can be asserted with a bang:
+  :John.likes! :beer      # likes(john, beer). in Prolog
+  :John.has! :beer        # has(john, beer). in Prolog
+
+Rules can be asserted with +if+ and +unless+:
+  X.drinks(Y).if X.has(Y).and X.likes(Y)         # drinks(X,Y) :- has(X,Y), likes(X,Y). in Prolog
+
+Queries can be proved with a question mark or with +true?+:
+  John.drinks? :beer         # => true
+  (John.drinks :beer).true?  # => true
+
+Or solutions can be enumerated (clauses include Enumerable)
+  (John.drinks X).each {|x| p x}  # outputs :beer
+  (John.drinks X).to_a            # => [:beer]
+
+At most places you can mix native Ruby with Rubylog by using a proc instead of a clause. Blocks are automatically converted to proc objects:
+  X.drinks(Y).if proc{|x,y| y.to_s =~ /^Z/ }
+  X.drinks(Y).if {|x,y| y.to_s =~ /^Z/ }     # the same
+
+  X.drinks(Y).if X.likes(Y).and proc { Time.now.hour == 12 }
+  X.drinks(Y).if X.likes(Y).and { Time.now.hour == 12 }     # the same
+
+Variable values are passed to the proc, in the order of appearance.
+
+Nullary predicates are just symbols:
+  John.drinks(:beer).if :true.or :false
+
+For predicates requiring a simple value as an argument, you can pass a proc that returns that value
+  X.drinks(Y).if Y.is proc{|x| $favorites[x] }
+  X.drinks(Y).if Y.is {|x| $favorites[x] }      # the same
+
+
+The Prolog built-in predicates and the Rubylog equivalents (see +Rubylog::Builtins+ for details):
+
+<table>
+<tr><th>Prolog</th><th>Rubylog</th></tr>
+<tr><td>+true+</td><td>+:true+</td></tr>
+<tr><td>+fail+</td><td>+:fail+</td></tr>
+<tr><td>+,+</td><td>+and+, +&+</td></tr>
+<tr><td>+;+</td><td>+or+, +|+</td></tr>
+<tr><td>+!+</td><td>+:cut+</td></tr>
+<tr><td>+->+</td><td>+then+</td></tr>
+<tr><td><tt>\\\+</tt></td><td>+is_false+, +fails+, +not+, +~+</td></tr>
+<tr><td>+repeat+</td><td>+repeat+</td></tr>
+<tr><td>+A=B+</td><td>+A.is B+</td></tr>
+<tr><td><tt>X is Y*5</tt></td><td><tt>X.is{|y|y*5}</tt></td></tr>
+<tr><td></td><td>+proc{|x,y|y===x}+ or +X.matches Y+</td></tr>
+<tr><td>+L=[H|T]+</td><td>+L.splits_to(H,T)+</td></tr>
+<tr><td>+member(A,L)+</td><td>+A.in L+ (+L+ can be any enumerable)</td></tr>
+<tr><td>+write(A)+</td><td>+A._puts+, +A._print+, +A._p+</td></tr>
+<tr><td>+nl+</td><td>+:nl+</td></tr>
+<tr><td><tt>\\\+((A, \\\+ B))</tt></td><td>+A.all B+</td></tr>
+<tr><td><tt>(A,B)->true</tt></td><td>+A.any B+</td></tr>
+<tr><td><tt></tt></td><td>+A.one B+</td></tr>
+<tr><td><tt>\\\+((A,B))</tt></td><td><tt>A.none B</tt></td></tr>
+
+</table>
+
+
+
+== Contributing to rubylog
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2012 Bernát Kalló. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+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.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.email = "kallo.bernat@gmail.com"
+  gem.authors = ["Bernát Kalló"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+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 'reek/rake/task'
+Reek::Rake::Task.new do |t|
+  t.fail_on_error = true
+  t.verbose = false
+  t.source_files = 'lib/**/*.rb'
+end
+
+require 'roodi'
+require 'roodi_task'
+RoodiTask.new do |t|
+  t.verbose = false
+end
+
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/examples/4queens.rb

@@ -0,0 +1,10 @@
+require "rubylog"
+
+Rubylog.use :variables, :implicit_predicates, String, Numeric
+
+4.queens!
+
+0.queens! []
+N.queens
+
+

data/examples/calculation.rb

@@ -0,0 +1,12 @@
+require 'rubylog'
+
+Rubylog.use :variables, :implicit_predicates, String
+
+Rubylog::Theory.new do
+  A.write.if {|a| puts a or true}
+  :hello.if "Hello, world!".write
+  :hello.prove
+end
+
+
+

data/examples/concepts.rb

@@ -0,0 +1,46 @@
+
+X.clause.if X.fact
+X.clause.if X.rule
+X.clause.if X.query
+
+X.comment.if X.starts_with('%')
+
+X.predicate.if X.procedure
+
+X.procedure.if X.has_many(clause)
+
+
+X.operator.if X.comparison_operator
+X.operator.if X.arithmetic_operator
+
+X.comparison_operator.if X.arithmetic_comparison_operator.or X.unification_style_operator
+
+X.unification_style_operator.if X === :===
+X.unification_style_operator.if X === :==
+
+X.arithmetic_comparison_operator.if X === :<
+X.arithmetic_comparison_operator.if X === :<=
+X.arithmetic_comparison_operator.if X === :>
+X.arithmetic_comparison_operator.if X === :>=
+
+X.arithmetic_operator.if X === :+
+X.arithmetic_operator.if X === :-
+X.arithmetic_operator.if X === :-@
+X.arithmetic_operator.if X === :*
+X.arithmetic_operator.if X === :/
+X.arithmetic_operator.if X === :%
+X.arithmetic_operator.if X === :**
+X.arithmetic_operator.if X === :<=>
+X.arithmetic_operator.if X === :&
+X.arithmetic_operator.if X === :|
+X.arithmetic_operator.if X === :^
+X.arithmetic_operator.if X === :~
+X.arithmetic_operator.if X === :<<
+X.arithmetic_operator.if X === :>>
+
+
+
+
+X.builtin.if X === :arg
+X.builtin.if X === :forget
+

data/examples/factorial.rb

@@ -0,0 +1,16 @@
+require 'rubylog'
+
+class << FactorialTheory = Rubylog::Theory.new!
+
+  0.factorial! 1
+  N.factorial(K).if proc{|n|n>0}.and N1.is{|n|n-1}.and N1.factorial(K1).and K.is{|n,_,_,k1| n*k1}
+
+  [0,1,2,7].each do |n|
+    (n.factorial? K).solve{|k| puts "#{n} factorial is #{k}"}
+  end
+
+  Integer.include_theory self
+
+end
+
+

data/examples/fp.rb

@@ -0,0 +1,56 @@
+=begin
+
+This is a port of some little Haskell programs
+
+
+
+
+
+zipPair :: ([a],[b]) -> [(a,b)]
+-- zipPair = uncurry zip
+zipPair (_,[]) = []
+zipPair ([],_) = []
+zipPair ((a:as), (b:bs)) = (a,b) : zipPair (as,bs)
+
+=end
+
+class << Rubylog::Theory.new!
+
+  rubylog_functor 
+
+  # multiply 0 _ = []
+  # multiply n k = k : multiply (n-1) k
+  #
+  (N.times X, XS).if XS.is{|n,x| n*[x] }
+
+
+  # dividers n = filter (`divides` n) [1..n `div` 2] 
+  #   where a `divides` b = b `mod` a == 0
+  # isPerfectNumber n = n == (sum $ dividers n)
+
+  (A.divides B).if {|a,b| b % a == 0}
+  (A.divider_of B).if A.in{|a,b| (1..b%2)}.and A.divides B
+  (N.perfect_number).if DS.is{|n| (D.divider_of n).to_a }.and DS.sum N
+  (L.sum S).if S.is{|l| l.inject(0){|a,b|a+b}}
+
+
+
+  # mirrorList [] = []
+  # mirrorList (a:as) = mirrorList as ++ [a]
+  (L.mirrored M).if M.is{|l|l.reverse}
+
+
+  # intermix [] _ = []
+  # intermix [a] _ = [a]
+  # intermix (a:as) b = a:b:intermix as b
+  (L.intermix E, M).if M.is{|l,e|l[1..-1].inject [l[0]] {|a,b| a << e << b }}
+  # possible:
+  #([].intermix ANY, [])
+  #([A].intermix ANY, [A])
+  #((:|[A,AS]).intermix B, :|[A,B,L]).if (AS.intermix B, L)
+
+
+end
+
+
+

data/examples/hello.rb

@@ -0,0 +1,9 @@
+require "rubylog"
+
+Rubylog.use :variables, :implicit_predicates, String
+
+A.write.if {|a| puts a; true}
+:hello.if "Hello, world!".write
+
+:hello.true?
+

data/examples/historia_de_espana.rb

@@ -0,0 +1,31 @@
+require 'rubylog'
+require 'pp'
+
+class << Rubylog::Theory.new!
+  Symbol.rubylog_functor :lugar_historico, :during
+  Integer.rubylog_functor :during
+
+  A.lugar_historico.if A.in [
+    :Hispania_prehistorica,
+    :Hispania_romana,
+    :Hispania_visigoda,
+    :Al_Andalus, 
+    :Imperio_espanol, 
+    :Reino_Constitucional_Espanol
+  ]
+
+  :Hispania_prehistorica.during! [-800000,200]
+  A.during([X,Y]).if A.matches(Integer).and {|a,x,y| (x..y) === a}
+
+  
+
+
+  def self.solve k
+    pp *k.solutions
+  end
+
+  puts
+  pp *(A.lugar_historico.and A.during(P).and 200.during(P)).variable_hashes
+
+
+end

data/examples/idea.rb

@@ -0,0 +1,143 @@
+
+
+
+# ActiveSpec
+user = User.new(:username => 'luke')
+spec = SizeSpecification.new(6, :username)
+spec.satisfied_by? user
+
+spec = CompositeSpecification.new
+spec.add_specification(SizeSpecification.new(6, :username))
+spec.add_specification(CollectionSpecification.new(18..30, :age))
+spec.add_specification(ConfirmationSpecification.new(:password))
+spec.satisfied_by?(User.new)
+#=> false
+
+# Rubylog
+user = User.new(:username => 'luke')
+U.username_valid.if U.size_of(:username,6)
+user.username_valid?
+
+# ActiveSpec
+spec = CollectionSpecification.new(1..10, :age)
+# or validates_inclusion_of :age, :in => 1..10
+spec_two = NotSpecification.new(CollectionSpecification.new(1..10, :age))
+# or validates_exclusion_of :age, :in => 1..10
+
+# Rubylog
+U.age_valid.if ~ U.is_included(:age, 1..10)
+
+# ActiveSpec
+spec = ProcSpecification.new(proc{ |object|
+  # do something with object
+  # and return true or false
+})
+spec.satisfied_by? some_object
+
+U.everything_valid.if {|u|
+  # do something w/ u and return true/false
+}
+
+# ActiveSpec
+class UserSpecification < ActiveSpec::Base
+	requires_presence_of :username, :password
+	requires_size 6, :password
+	requires_confirmation_of :password
+	requires_inclusion_in 18..30, :age
+end
+UserSpecification.satisfied_by?(some_user)
+
+# Rubylog
+UserValidationTheory = Rubylog::Theory.new do
+protected
+  U.invalid.if (U.username=N) & N.blank
+  U.invalid.if (U.password=P) & P.size=K & K.is_not 6
+  U.invalid.if (U.password_confirmation=C) & (U.password=P) & (K.is_not P)
+  U.invalid.if (U.age=A) & ~:include[18..30, A]
+public
+  U.valid_user.if ~U.invalid
+end
+
+User.include_theory UserValidationTheory
+some_user.valid_user?
+
+
+# ActiveSpec
+specification :valid_user do
+  requires_presence_of :username, :password
+  requires_confirmation_of :password
+  must_satisfy :another_specification
+end
+
+ValidUserSpecification.satisfied_by?(some_user)
+
+# Rubylog
+# app/theories/valid_user_theory.rb
+theory :valid_user do
+  U.valid_user.if ~U.invalid
+protected
+  U.invalid.if (U.username=N) & N.blank
+  U.invalid.if (U.password=P) & P.size=K & K.is_not 6
+  U.invalid.if (U.password_confirmation=C) & (U.password=P) & (K.is_not P)
+  U.invalid.if (U.age=A) & ~:include[18..30, A]
+end
+
+User.include_theory :valid_user
+some_user.valid_user?
+
+
+
+
+
+# ActiveSpec
+class User
+  must_satisfy :valid_user_specification
+
+  # optional :if argument takes a symbol or a block
+  # and can be used for conditional evaluation of
+  # specifications
+  must_satisfy :activated_user_specification, :if => :activated?
+end
+
+user = User.new
+user.satisfies_specs?
+# evaluates ValidUserSpecification
+user.activated = true
+user.satisfies_specs?
+# evaluates both specifications
+
+
+# Rubylog
+class User
+  include_theory :valid_user, :activated_user
+  def satisfies_specs?
+    !bad?
+  end
+end
+
+theory :valid_user do
+  U.bad.if ~U.valid_user
+protected
+  #...
+end
+
+theory :activated_user do
+  U.bad.if U.activated.and ~U.valid_activated_user
+protected
+  # ...
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

data/examples/lists.rb

@@ -0,0 +1,5 @@
+require 'rubylog'
+
+class << Rubylog.theory
+end
+