ruby-prolog 0.0.5

data/History.txt

@@ -0,0 +1,19 @@
+== 0.0.4 / 2009-02-09
+
+* Fixing packaging error from previous build.
+
+== 0.0.3 / 2009-02-09
+
+* Renaming files due to RubyForge stupidity.
+* Adding usage examples.
+
+== 0.0.2 / 2009-02-04
+
+* Refactored the code into an object-oriented state.
+* Changed #query to not print results and return goals.
+* Made spec tests more meaningful.
+* Addressed small TODO items.
+
+== 0.0.1 / 2009-01-14
+
+* First release. Basically a glorified packaging of tiny_prolog and various extensions.

data/Manifest

@@ -0,0 +1,10 @@
+examples/acls.rb
+examples/hanoi.rb
+History.txt
+lib/ruby-prolog/ruby-prolog.rb
+lib/ruby-prolog.rb
+Manifest
+Rakefile
+README.txt
+spec/ruby-prolog_spec.rb
+spec/spec_helper.rb

data/README.txt

@@ -0,0 +1,57 @@
+ruby_prolog
+    by Preston Lee
+    http://openrain.com
+	The core engine is largely based on tiny_prolog, though numerous additional enhancements have been made
+	such as object-oriented refactorings and integration of ideas from the interwebs. Unfortunately I cannot
+	read Japanese and cannot give proper attribution to the original tiny_prolog author. If *you* can, let
+	me know and I'll update this document!
+
+== DESCRIPTION:
+
+	An object-oriented pure Ruby implementation of a Prolog-like DSL for easy AI and logical programming.
+
+== FEATURES/PROBLEMS:
+
+* Pure Ruby.
+* Tested with Ruby 1.8.7 (MRI). 
+* Object-oriented.
+* Multiple Prolog environments can be created and manipulated simultaneously.
+* Concurrent access to different core instances should be safe.
+* Concurrent access to a single core instance might probably explode in odd ways.
+
+== SYNOPSIS:
+
+  See ruby_prolog_spec.rb for usage examples.
+
+== REQUIREMENTS:
+
+* Should work under all popular Ruby interpreters. Please report compatibility problems.
+
+== INSTALL:
+
+* sudo gem install ruby_prolog
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 OpenRain, LLC
+
+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/Rakefile

@@ -0,0 +1,10 @@
+require 'echoe'  
+Echoe.new("ruby-prolog") do |p|
+    p.author = "Preston Lee"
+    p.summary = "A Prolog-ish Ruby DSL."
+    p.url = "http://www.openrain.com.com"
+    # p.docs_host = "uncapitalizer.com:~/www/files/doc/"
+    # p.runtime_dependencies = ["string_tools >=1.4.0"]
+    p.version = '0.0.5'
+    p.email = "preston.lee@openrain.com"
+end

data/examples/acls.rb

@@ -0,0 +1,77 @@
+require 'rubygems'
+require 'ruby-prolog'
+
+c = RubyProlog::Core.new
+c.instance_eval do
+
+  # Let's put together an issue tracking system for Microsoft.
+  
+  # We'll start by declaring a few projects...
+  project_status['me', 'live'].fact
+  project_status['xp', 'live'].fact
+  project_status['vista', 'live'].fact
+  project_status['7', 'in_progress'].fact
+  
+  
+  # Now we'll create a custom ACL system...
+  role_can['user', 'create'].fact
+  role_can['user', 'read'].fact
+
+  role_can['qa', 'create'].fact
+  role_can['qa', 'read'].fact
+  role_can['qa', 'update'].fact
+
+  role_can['admin', 'create'].fact
+  role_can['admin', 'read'].fact
+  role_can['admin', 'update'].fact
+  role_can['admin', 'delete'].fact
+  
+  
+  # Let's put people on different projects
+  assigned['alice', 'me', 'user'].fact
+  assigned['bob', 'me', 'qa'].fact
+  assigned['charlie', 'me', 'qa'].fact
+  
+  assigned['alice', 'xp', 'user'].fact
+  assigned['bob', 'xp', 'user'].fact
+  assigned['charlie', 'xp', 'admin'].fact
+
+  assigned['alice', 'vista', 'qa'].fact
+  assigned['bob', 'vista', 'admin'].fact
+  assigned['charlie', 'vista', 'admin'].fact
+
+  assigned['alice', '7', 'user'].fact
+  assigned['bob', '7', 'qa'].fact
+  assigned['charlie', '7', 'qa'].fact
+  assigned['dale', '7', 'admin'].fact
+  
+  
+  # can_read_on_project[:U, :P] <<= [assigned[:U, :P, :R], role_can[:R, 'read']]
+  can_on_project[:U, :X, :P] <<= [assigned[:U, :P, :R], role_can[:R, :X]]
+  is_role_on_multiple_projects[:U, :R] <<= [assigned[:U, :X, :R], assigned[:U, :Y, :R], noteq[:X, :Y]]
+  # , noteq[:P1, :P2]
+  
+  puts 'Who does QA?'
+  p query(assigned[:U, :P, 'qa'])
+    
+  puts "Who can access the 'vista' project?"
+  p query(can_on_project[:U, 'read', 'vista'])
+  
+  puts "Does Alice have delete privileges on Vista?"
+  puts query(can_on_project['alice', 'delete', 'vista']).empty? ? "Yes" : "No"
+
+  puts "Does Bob have delete privileges on Vista?"
+  puts query(can_on_project['bob', 'delete', 'vista']).empty? ? "Yes" : "No"
+  
+  puts "Who is an admin on multiple projects?"
+  # p query(is_role_on_multiple_projects[:U, 'admin'])
+  
+  s = Array.new
+  query(is_role_on_multiple_projects[:U, 'admin']).each do |r|
+    s |= [r[0].args[0]] # Put each result into the array, if not already present.
+  end
+  s.each do |n| puts n end # Print all unique results!
+  
+  
+
+end

data/examples/hanoi.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'ruby-prolog'
+
+# require File.join(File.dirname(__FILE__), %w[.. lib ruby-prolog])
+
+# Inspired by..
+# http://www.csupomona.edu/~jrfisher/www/prolog_tutorial/2_3.html
+# http://eigenclass.org/hiki.rb?tiny+prolog+in+ruby
+
+c = RubyProlog::Core.new
+c.instance_eval do
+
+  move[0,:X,:Y,:Z] <<= :CUT   # There are no more moves left
+  move[:N,:A,:B,:C] <<= [
+    is(:M,:N){|n| n - 1}, # reads as "M IS N - 1"
+    move[:M,:A,:C,:B],
+    write_info[:A,:B],
+    move[:M,:C,:B,:A]
+  ]
+  write_info[:X,:Y] <<= [
+    write["move a disc from the "],
+    write[:X], write[" pole to the "],
+    write[:Y], writenl[" pole "]
+  ]
+   
+   hanoi[:N] <<=  move[:N,"left","right","center"]
+
+   puts "\nWhat's the solution for a single disc?"
+   query(hanoi[1])
+
+   puts "\n\nWhat's the solution for 5 discs?"
+   query(hanoi[5])
+   
+   # do_stuff[:STUFF].calls{|env| print env[:STUFF]; true}
+    
+end

data/lib/ruby-prolog.rb

@@ -0,0 +1,49 @@
+
+module RubyProlog
+
+  # :stopdoc:
+  VERSION = '0.0.5'
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+  # Utility method used to rquire all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+end  # module RubyProlog
+
+RubyProlog.require_all_libs_relative_to(__FILE__)
+
+# EOF

data/lib/ruby-prolog/ruby-prolog.rb

@@ -0,0 +1,366 @@
+# Based on tiny_prolog h18.9/8
+
+module RubyProlog
+
+  
+  class Predicate
+  
+    attr_reader :defs
+
+    def initialize(name)
+      @name = name
+      @defs = []
+    end
+
+    def inspect
+      return @name.to_s
+    end
+
+    def [](*args)
+      return Goal.new(self, args)
+    end
+
+    def []=(*a); end
+   
+  end
+
+
+  class Goal
+
+    attr_reader :pred, :args
+
+    def list(*x)
+      y = nil
+      x.reverse_each {|e| y = Cons.new(e, y)}
+      return y
+    end
+    
+    def initialize(pred, args)
+      @pred, @args = pred, args
+    end
+
+    def si(*rhs)                  # ラテン語の「もしも」
+      @pred.defs << [self, list(*rhs)]
+    end
+
+    def fact
+      si
+    end
+
+    def <<(rhs)
+      case rhs
+      when Array
+        si(*rhs)
+      else
+        si(rhs)
+      end
+    end
+
+    def calls(&callback)
+      @pred.defs << [self, callback]
+    end
+
+    def inspect
+      return @pred.inspect.to_s + @args.inspect.to_s
+    end
+
+  end
+
+
+  # Lisp のリスト風の二項組
+  class Cons < Array
+
+    def initialize(car, cdr)
+      super(2)
+      self[0], self[1] = car, cdr
+    end
+
+    def inspect
+      repr = proc {|x|
+        car, cdr = x[0], x[1]
+        if cdr.nil? then [car.inspect]
+        elsif Cons === cdr then repr[cdr].unshift(car.inspect)
+        else [car.inspect, '.', cdr.inspect]
+        end
+      }
+      return '(' + repr[self].join(' ') + ')'
+    end
+
+  end
+
+
+
+  class Environment
+
+    def initialize
+      @table = {}
+    end
+
+    def put(x, pair)
+      @table[x] = pair
+    end
+
+    def get(x)
+      return @table[x]
+    end
+
+    def delete(x)
+      @table.delete(x) {|k| raise "#{k} not found in #{inspect}"}
+    end
+
+    def clear
+      @table.clear
+    end
+
+    def dereference(t)
+      env = self
+      while Symbol === t
+        p = env.get(t)
+        break if p.nil?
+        t, env = p
+      end
+      return [t, env]
+    end
+
+    def [](t)
+      t, env = dereference(t)
+      return case t
+             when Goal then Goal.new(t.pred, env[t.args])
+             when Cons then Cons.new(env[t[0]], env[t[1]])
+             when Array then t.collect {|e| env[e]}
+             else t
+             end
+    end
+    
+    
+  end
+
+
+  class CallbackEnvironment
+  
+    def initialize(env, trail, core)
+      @env, @trail, @core = env, trail, core
+    end
+  
+    def [](t)
+      return @env[t]
+    end
+  
+    def unify(t, u)
+      # pp "CORE " + @core
+      return @core._unify(t, @env, u, @env, @trail, @env)
+    end
+  
+  end
+
+
+  class Core
+
+    def _unify(x, x_env, y, y_env, trail, tmp_env)
+
+      loop {
+        if Symbol === x
+          xp = x_env.get(x)
+          if xp.nil?
+            y, y_env = y_env.dereference(y)
+            unless x == y and x_env == y_env
+              x_env.put(x, [y, y_env])
+              trail << [x, x_env] unless x_env == tmp_env
+            end
+            return true
+          else
+            x, x_env = xp
+            x, x_env = x_env.dereference(x)
+          end
+        elsif Symbol === y
+          x, x_env, y, y_env = y, y_env, x, x_env
+        else
+          break
+        end
+      }
+
+      if Goal === x and Goal === y
+        return false unless x.pred == y.pred
+        x, y = x.args, y.args
+      end
+  
+      if Array === x and Array === y
+        return false unless x.length == y.length
+        for i in 0 ... x.length     # x.each_index do |i| も可
+          return false unless _unify(x[i], x_env, y[i], y_env, trail, tmp_env)
+        end
+        return true
+      else
+        return x == y
+      end
+
+    end
+
+
+    def list(*x)
+      y = nil
+      x.reverse_each {|e| y = Cons.new(e, y)}
+      return y
+    end
+    
+    
+    def resolve(*goals)
+      env = Environment.new
+      _resolve_body(list(*goals), env, [false]) {
+        yield env
+      }
+    end
+
+
+    def _resolve_body(body, env, cut)
+      if body.nil?
+        yield
+      else
+        goal, rest = body
+        if goal == :CUT
+          _resolve_body(rest, env, cut) {
+            yield
+          }
+          cut[0] = true
+        else
+          d_env = Environment.new
+          d_cut = [false]
+          require 'pp'
+          # pp 'G ' + goal.class.to_s
+          # pp goal.pred
+          for d_head, d_body in goal.pred.defs
+          # for d_head, d_body in goal.defs
+            break if d_cut[0] or cut[0]
+            trail = []
+            if _unify_(goal, env, d_head, d_env, trail, d_env)
+              if Proc === d_body
+                if d_body[CallbackEnvironment.new(d_env, trail, self)]
+                  _resolve_body(rest, env, cut) {
+                    yield
+                  }
+                end
+              else
+                _resolve_body(d_body, d_env, d_cut) {
+                  _resolve_body(rest, env, cut) {
+                    yield
+                  }
+                  d_cut[0] ||= cut[0]
+                }
+              end
+            end
+            for x, x_env in trail
+              x_env.delete(x)
+            end
+            d_env.clear
+          end
+        end
+      end
+    end
+
+
+    $_trace = false
+    def trace(flag)
+      $_trace = flag
+    end
+
+
+    def _unify_(x, x_env, y, y_env, trail, tmp_env)
+      lhs, rhs = x_env[x].inspect, y.inspect if $_trace
+      unified = _unify(x, x_env, y, y_env, trail, tmp_env)
+      printf("\t%s %s %s\n", lhs, (unified ? "~" : "!~"), rhs) if $_trace
+      return unified
+    end
+
+
+    def query(*goals)
+      count = 0
+      results = Array.new
+      # printout = proc {|x|
+      #   x = x[0] if x.length == 1
+      #   printf "%d %s\n", count, x.inspect
+      # }
+      resolve(*goals) {|env|
+        count += 1
+        results << env[goals]
+        # printout[env[goals]]
+      }
+      # printout[goals] if count == 0
+      return results
+    end
+  
+  
+    def is(*syms,&block)
+      $is_cnt ||= 0
+      is = Predicate.new "IS_#{$is_cnt += 1}"
+      raise "At least one symbol needed" unless syms.size > 0
+      is[*syms].calls do |env|
+        value = block.call(*syms[1..-1].map{|x| env[x]})
+        env.unify(syms.first, value)
+      end
+      is[*syms]
+    end
+
+    def method_missing(meth, *args)
+        # puts "NEW PRED #{meth} #{meth.class}"
+        pred = Predicate.new(meth)
+        # proc = Proc.new {pred}
+
+
+        # We only want to define the method on this specific object instance to avoid polluting global namespaces.
+        
+        # You can't do this..
+        # class << self
+        #           module_eval do
+        #             send(:define_method, m, proc)
+        #           end
+        #         end
+        
+        # Nor this..
+        # define_method(meth) {pred}
+
+        # Nor this..
+        # self.send(:define_method, meth, proc)
+        
+        # And you don't want to pollute the global namespace like this...
+        # Object.class_eval{ define_method(meth){pr} }
+        
+        
+        # Sooooo... I know this doesn't really make intuitive sense,
+        # but you need to get the eigenclass and then define
+        # the method within that context in such a way that we
+        # have access to local variables, like this...
+        class << self; self; end.module_eval do
+          define_method meth, Proc.new{pred}
+        end
+        # ...which is major fuglytown, but I don't know how to do it any other way.
+
+        return pred
+    end
+
+  
+    def initialize
+      # We do not need to predefine predicates like this because they will automatically be defined for us.
+      # write = Predicate.new "write"
+      write[:X].calls{|env| print env[:X]; true}
+      writenl[:X].calls{|env| puts env[:X]; true}
+      nl[:X].calls{|e| puts; true}
+      eq[:X,:Y].calls{|env| env.unify(env[:X], env[:Y])}
+      noteq[:X,:Y].calls{|env| env[:X] != env[:Y]}
+      atomic[:X].calls do |env|
+        case env[:X]
+        when Symbol, Predicate, Goal; false
+        else true
+        end
+      end
+      notatomic[:X].calls do |env|
+        case env[:X]
+        when Symbol, Predicate, Goal; true
+        else false
+        end
+      end
+      numeric[:X].calls{|env| Numeric === env[:X] }
+    end
+
+  end
+
+end

data/ruby-prolog.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{ruby-prolog}
+  s.version = "0.0.5"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Preston Lee"]
+  s.date = %q{2009-02-09}
+  s.description = %q{A Prolog-ish Ruby DSL.}
+  s.email = %q{preston.lee@openrain.com}
+  s.extra_rdoc_files = ["lib/ruby-prolog/ruby-prolog.rb", "lib/ruby-prolog.rb", "README.txt"]
+  s.files = ["examples/acls.rb", "examples/hanoi.rb", "History.txt", "lib/ruby-prolog/ruby-prolog.rb", "lib/ruby-prolog.rb", "Manifest", "Rakefile", "README.txt", "spec/ruby-prolog_spec.rb", "spec/spec_helper.rb", "ruby-prolog.gemspec"]
+  s.has_rdoc = true
+  s.homepage = %q{http://www.openrain.com.com}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Ruby-prolog", "--main", "README.txt"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{ruby-prolog}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{A Prolog-ish Ruby DSL.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/spec/ruby-prolog_spec.rb

@@ -0,0 +1,222 @@
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+
+describe RubyProlog do
+
+  
+  # before :each do
+  # end
+  
+  
+  it 'should not pollute the global namespace with predicates.' do
+    
+    # We'll create numerous instances of the engine and assert they do not interfere with each other.
+     one = RubyProlog::Core.new
+     one.instance_eval do
+       query(male[:X]).length.should == 0
+     end
+
+     two = RubyProlog::Core.new
+     two.instance_eval do
+       male[:preston].fact
+       query(male[:X]).length.should == 1
+     end
+     
+     three = RubyProlog::Core.new
+     three.instance_eval do
+       query(male[:X]).length.should == 0
+     end
+     
+     one.instance_eval do
+       query(male[:X]).length.should == 0
+     end
+
+  end
+  
+
+
+  it 'should be able to query simple family trees.' do
+
+    c = RubyProlog::Core.new
+    c.instance_eval do
+      # Basic family tree relationships..
+      sibling[:X,:Y] <<= [ parent[:Z,:X], parent[:Z,:Y], noteq[:X,:Y] ]
+      mother[:X,:Y] <<= [parent[:X, :Y], female[:X]]
+      father[:X,:Y] <<= [parent[:X, :Y], male[:X]]
+      grandparent[:G,:C] <<= [ parent[:G,:P], parent[:P,:C]]
+      ancestor[:A, :C] <<= [parent[:A, :X], parent[:X, :B]]
+      mothers[:M, :C] <<= mother[:M, :C]
+      mothers[:M, :C] <<= [mother[:M, :X], mothers[:X, :C]]
+      fathers[:F, :C] <<= father[:F, :C]
+      fathers[:F, :C] <<= [father[:F, :X], fathers[:X, :C]]
+      widower[:W] <<= [married[:W, :X], deceased[:X], nl[deceased[:W]]]
+      widower[:W] <<= [married[:X, :W], deceased[:X], nl[deceased[:W]]]
+
+      # Basic parents relationships as could be stored in a typical relational database.
+      parent['Ms. Old', 'Marge'].fact
+
+      parent['Carol', 'Ron'].fact
+      parent['Kent', 'Ron'].fact
+      parent['Marge', 'Marcia'].fact
+      parent['Pappy', 'Marcia'].fact
+
+      parent['Marcia', 'Karen'].fact
+      parent['Marcia', 'Julie'].fact
+      parent['Ron', 'Karen'].fact
+      parent['Ron', 'Julie'].fact
+
+      parent['Matt', 'Silas'].fact
+      parent['Julie', 'Silas'].fact
+      parent['Preston', 'Cirrus'].fact # Technically our dog.. but whatever :)
+      parent['Karen', 'Cirrus'].fact
+
+
+      # Gender facts..
+      male['Preston'].fact
+      male['Kent'].fact
+      male['Pappy'].fact
+      male['Ron'].fact
+      male['Matt'].fact
+      female['Ms. Old'].fact
+      female['Carol'].fact
+      female['Marge'].fact
+      female['Marcia'].fact
+      female['Julie'].fact
+      female['Karen'].fact
+
+
+      # People die :(
+      deceased['Pappy'].fact
+
+
+      # Let's marry some people..
+      married['Carol', 'Kent'].fact
+      married['Marge', 'Pappy'].fact
+      married['Ron', 'Marcia'].fact
+      married['Matt', 'Julie'].fact
+      married['Preston', 'Karen'].fact
+
+
+      # And add some facts on personal interests..
+      interest['Karen', 'Music'].fact
+      interest['Karen', 'Movies'].fact
+      interest['Karen', 'Games'].fact
+      interest['Karen', 'Walks'].fact
+      interest['Preston', 'Music'].fact
+      interest['Preston', 'Movies'].fact
+      interest['Preston', 'Games'].fact
+
+      interest['Silas', 'Games'].fact
+      interest['Cirrus', 'Games'].fact
+      interest['Karen', 'Walks'].fact
+      interest['Ron', 'Walks'].fact
+      interest['Marcia', 'Walks'].fact
+      
+      # Runs some queries..
+      
+      # p "Who are Silas's parents?"
+      # Silas should have two parents: Matt and Julie.
+      r = query(parent[:P, 'Silas'])
+      r.length.should == 2
+      r[0][0].args[0].should == 'Matt'
+      r[1][0].args[0].should == 'Julie'
+      
+      # p "Who is married?"
+      # We defined 5 married facts.
+      query(married[:A, :B]).length.should == 5
+        
+      # p 'Are Karen and Julie siblings?'
+      # Yes, through two parents.
+      query(sibling['Karen', 'Julie']).length.should == 2
+      
+      
+      # p "Who likes to play games?"
+      # Four people.
+      query(interest[:X, 'Games']).length.should == 4
+      
+      
+      # p "Who likes to play checkers?"
+      # Nobody.
+      query(interest[:X, 'Checkers']).length.should == 0
+
+      # p "Who are Karen's ancestors?"
+      # query(ancestor[:A, 'Karen'])
+
+      # p "What grandparents are also widowers?"
+      # Marge, twice, because of two grandchildren.
+      query(widower[:X], grandparent[:X, :G]).length.should == 2
+    end
+
+  end
+
+
+  it 'should be able to query simple family trees.' do
+
+    c = RubyProlog::Core.new
+    c.instance_eval do
+
+      vendor['dell'].fact
+      vendor['apple'].fact
+      
+      model['ultrasharp'].fact
+      model['xps'].fact
+      model['macbook'].fact
+      model['iphone'].fact
+      
+      manufactures['dell', 'ultrasharp'].fact
+      manufactures['dell', 'xps'].fact
+      manufactures['apple', 'macbook'].fact
+      manufactures['apple', 'iphone'].fact
+      
+      is_a['xps', 'laptop'].fact
+      is_a['macbook', 'laptop'].fact
+      is_a['ultrasharp', 'monitor'].fact
+      is_a['iphone', 'phone'].fact
+      
+      kind['laptop']
+      kind['monitor']
+      kind['phone']
+      
+      model[:M] <<= [manfactures[:V, :M]]
+      
+      vendor_of[:V, :K] <<= [vendor[:V], manufactures[:V, :M], is_a[:M, :K]]
+      # not_vendor_of[:V, :K] <<= [vendor[:V], nl[vendor_of[:V, :K]]]
+
+      query(is_a[:K, 'laptop']).length == 2
+      query(vendor_of[:V, 'phone']) == 1
+      # pp query(not_vendor_of[:V, 'phone'])
+    end
+    
+  end
+  
+  
+  it 'should solve the Towers of Hanoi problem.' do
+    c = RubyProlog::Core.new
+    c.instance_eval do
+
+      move[0,:X,:Y,:Z] <<= :CUT   # There are no more moves left
+      move[:N,:A,:B,:C] <<= [
+        is(:M,:N){|n| n - 1}, # reads as "M IS N - 1"
+        move[:M,:A,:C,:B],
+        # write_info[:A,:B],
+        move[:M,:C,:B,:A]
+      ]
+      write_info[:X,:Y] <<= [
+        # write["move a disc from the "],
+        # write[:X], write[" pole to the "],
+        # write[:Y], writenl[" pole "]
+      ]
+
+       hanoi[:N] <<=  move[:N,"left","right","center"]
+       query(hanoi[5]).length.should == 1
+
+       # do_stuff[:STUFF].calls{|env| print env[:STUFF]; true}
+
+    end  
+    
+  end
+  
+  
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'rubygems'
+require 'spec'
+require File.expand_path(File.join(File.dirname(__FILE__), %w[.. lib ruby-prolog]))
+
+Spec::Runner.configure do |config|
+  # == Mock Framework
+  #
+  # RSpec uses it's own mocking framework by default. If you prefer to
+  # use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+end
+
+# EOF

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: ruby-prolog
+version: !ruby/object:Gem::Version 
+  version: 0.0.5
+platform: ruby
+authors: 
+- Preston Lee
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-09 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: A Prolog-ish Ruby DSL.
+email: preston.lee@openrain.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- lib/ruby-prolog/ruby-prolog.rb
+- lib/ruby-prolog.rb
+- README.txt
+files: 
+- examples/acls.rb
+- examples/hanoi.rb
+- History.txt
+- lib/ruby-prolog/ruby-prolog.rb
+- lib/ruby-prolog.rb
+- Manifest
+- Rakefile
+- README.txt
+- spec/ruby-prolog_spec.rb
+- spec/spec_helper.rb
+- ruby-prolog.gemspec
+has_rdoc: true
+homepage: http://www.openrain.com.com
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Ruby-prolog
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: ruby-prolog
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: A Prolog-ish Ruby DSL.
+test_files: []
+