ruby-prolog 1.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 95ccd423807966099f72796cd208b6f6f3a67e04
-  data.tar.gz: e7466c847b517b701e7af1e7ed0d3a475e0120fb
+SHA256:
+  metadata.gz: ffa39b815b60de57f1865b1c5b2abd00345623c2d90a81c4185f5800bfe957ca
+  data.tar.gz: 2b279f1a9c1e6cfb9320de5c52a6ee484f47e62f1001a58d3bd17c56ff9fca57
 SHA512:
-  metadata.gz: 12038b878dd73582ed9dd113145f87a1275a1b6ce754ce8c7a802c4a68f0e3eb44e6fc3b0c91d0ab167fa929155b3bf8801ea671fb12d1ada5caa4f3b9d05f1f
-  data.tar.gz: bbaa1e1e15f8a851760b82178fa2b19ff66a68f0d1b0e7c57a9b74e9762415c6f6651fcb30f1dbd2e136689e8161c6f5f17c25df85373834f71503d5772399b3
+  metadata.gz: 6efaec42888b2749232637261b933e3a07c0a889b4ebc73995b7252e02048438b74b11d9c55a24e2687ecb0581e6d3c6d1efaad43444e3fa4601b5bc9165c432
+  data.tar.gz: f73024546d7bfd77b39fbd738bd06eacb0b1b3f025309fc55b3a43e332e7b2b8c8ab714db399886a62003a1b261ceab2ed65ee5d7adff9ac3cb267a399a864de

data/Gemfile

@@ -1,4 +1,8 @@
 source 'https://rubygems.org'
-ruby '2.0.0'
+ruby '~> 2.0'
 
 gemspec
+
+group :test do
+  gem 'minitest-focus', '~> 1.1.2'
+end

data/README.md

@@ -1,50 +1,134 @@
-ruby_prolog
+ruby-prolog
 ====
 
-An object-oriented pure Ruby implementation of a Prolog-like DSL for easy AI and logical programming. It should work under all popular Ruby interpreters. Please report compatibility problems.
+ruby-prolog allows you to solve complex logic problems on the fly using a dynamic, Prolog-like DSL inline with your normal Ruby code. Basic use is encompassed by stating basic facts using your data, defining rules, and then asking questions. Why is this cool? Because ruby-prolog allows you to leave your normal object-oriented vortex on demand and step into the alternate reality of declarative languages.
 
-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!)
+With ruby-prolog:
 
+* There are no classes.
+* There are no functions.
+* There are no variables.
+* There are no control flow statements.
+
+You *can* use all these wonder things -- it’s still Ruby after all -- but they’re not needed, and mainly useful for getting data and results into/out of the interpreter. Prolog still tends to be favored heavily in artificial intelligence and theorem proving applications and is still relevant to computer science curricula as well, so I hope this updated release proves useful for your logic evaluation needs!
+
+ruby-prolog is written using object-oriented-ish pure Ruby, and should work under all most popular Ruby interpreters. Please report compatibility problems. 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!)
 
 Usage
 ----
 
-Two runnable examples are included in the 'bin' directory. The first..
+Say you want to write the following Prolog code:
 
-    ruby-prolog-hanoi
+```
+implication(a, b).
+implication(b, c).
+implication(c, d).
+implication(c, x).
+
+implies(A, B) :- implication(A, B).
+implies(A, B) :- implication(A, Something), implies(Something, B).
+```
+
+Here's the equivalent Ruby code using this library:
+
+```rb
+db = RubyProlog.new do
+  implication['a', 'b'].fact
+  implication['b', 'c'].fact
+  implication['c', 'd'].fact
+  implication['c', 'x'].fact
+
+  implies[:A, :B] << implication[:A, :B]
+  implies[:A, :B] << [
+    implication[:A, :Something],
+    implies[:Something, :B]
+  ]
+end
+```
+
+Now you can run some queries:
+
+```rb
+# What are all the direct implications of 'c'?
+db.query{ implication['c', :X] }
+#=> [{ X: 'd' }, { X: 'x' }]
+
+# What are all the things that can directly imply?
+db.query{ implication[:X, :_] }
+#=> [{ X: 'a' }, { X: 'b' }, { X: 'c' }, { X: 'c' }]
+
+# What are all the things 'a' implies?
+db.query{ implies['a', :X] }
+#=> [{ X: 'b' }, { X: 'c' }, { X: 'd' }, { X: 'x' }]
+```
+
+Unfortunately if you have **two** predicates in a query, you can't just use a comma. There two ways to solve this problem:
+
+```rb
+# Solution 1: Use an array
+db.query{[ implication['b', :S], implies[:S, :B] ]}
+
+# Solution 2: Use a beneign assignment
+db.query{_= implication['b', :S], implies[:S, :B] }
+```
+
+If you need to add to your database, you can call `instance_eval`:
 
-..is a ruby-prolog solution to the well-known "Towers of Hanoi" problem in computer science. The second..
+```rb
+db = RubyProlog.new do
+  implication['a', 'b'].fact
+  implication['b', 'c'].fact
+end
+
+# Later...
+db.instance_eval do
+  implication['c', 'd'].fact
+  implication['c', 'x'].fact
+end
+```
+
+This will mutate your database. If you want to "fork" your database instead, you can call `db.clone`, which will return a new instance with all stored data. Cloning like this is optimized to copy as little as possible.
+
+Examples
+----
+
+    gem install ruby-prolog
+
+Two runnable examples are included in the 'bin' directory. The first..
 
     ruby-prolog-acls
 
-..shows the ruby-prolog DSL can be trivially used to implement an access control system. If you have some other useful or clever examples, please contribute them!
+..shows the ruby-prolog dynamic DSL used to trivially implement access control checks. The second..
 
 
+    ruby-prolog-hanoi
+
+..is a ruby-prolog solution to the well-known "Towers of Hanoi" problem in computer science. It's not clear, but something Prolog hackers will be interested in. If you have other useful or clever examples, please send a pull request!
+
+See the test/ directory for additional examples.
+
 Features
 ----
 
 * Pure Ruby.
-* Tested with Ruby 2.0.0! 
+* No wacko dependencies.
+* Tested with Ruby 2.0.0!
 * 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.
 
-
-Installation
+Development
 ----
 
-    gem install ruby_prolog
-
-See ruby_prolog_spec.rb for usage examples. 
-
+```
+$ git clone https://github.com/preston/ruby-prolog
+$ cd ruby-prolog
+$ bundle
+$ rake test
+```
 
 License
 ----
 
-Released under the Apache 2 license.
-
-Copyright (c) 2013 Preston Lee. All rights reserved. http://prestonlee.com
+Released under the Apache 2 license. Copyright (c) 2013 Preston Lee. All rights reserved. http://prestonlee.com

data/bin/ruby-prolog-acls

@@ -51,9 +51,9 @@ c.instance_eval do
   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] <<= [
+  # 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]]
@@ -82,4 +82,4 @@ c.instance_eval do
   
   
 
-end
+end

data/bin/ruby-prolog-hanoi

@@ -12,20 +12,20 @@ require 'ruby-prolog'
 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] <<= [
+  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_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"]
+   hanoi[:N] <<  move[:N,"left","right","center"]
 
    puts "\nWhat's the solution for a single disc?"
    query(hanoi[1])
@@ -35,4 +35,4 @@ c.instance_eval do
    
    # do_stuff[:STUFF].calls{|env| print env[:STUFF]; true}
     
-end
+end

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

@@ -2,14 +2,23 @@
 # Fuglied by Preston Lee.
 module RubyProlog
 
-  
+  def self.new(&block)
+    c = Core.new
+    c.instance_eval(&block) if block_given?
+    c
+  end
+
   class Predicate
-  
-    attr_reader :defs
+    @@id_counter = 0
+
+    attr_reader :id, :name
+    attr_accessor :db, :clauses
 
-    def initialize(name)
+    def initialize(db, name)
+      @id = (@@id_counter += 1)
+      @db = db
       @name = name
-      @defs = []
+      @clauses = []
     end
 
     def inspect
@@ -17,30 +26,36 @@ module RubyProlog
     end
 
     def [](*args)
-      return Goal.new(self, args)
+      return TempClause.new(@db, self, args)
     end
 
-    def []=(*a); end
-   
-  end
-
-
-  class Goal
-
-    attr_reader :pred, :args
+    def to_prolog
+      @clauses.map do |head, body|
+        "#{head.to_prolog}#{body ? " :- #{body.to_prolog}" : ''}."
+      end.join("\n")
+    end
 
-    def list(*x)
-      y = nil
-      x.reverse_each {|e| y = Cons.new(e, y)}
-      return y
+    def fork(new_db)
+      dupe = self.clone
+      dupe.db = new_db
+      dupe.clauses = dupe.clauses.dup
+      dupe
     end
-    
-    def initialize(pred, args)
-      @pred, @args = pred, args
+  end
+
+  class TempClause
+    def initialize(db, pred, args)
+      @db, @pred, @args = db, pred, args
     end
 
     def si(*rhs)
-      @pred.defs << [self, list(*rhs)]
+      goals = rhs.map do |x|
+        case x
+        when TempClause then x.to_goal
+        else x
+        end
+      end
+      @db.append(self.to_goal, list(*goals))
     end
 
     def fact
@@ -57,13 +72,69 @@ module RubyProlog
     end
 
     def calls(&callback)
-      @pred.defs << [self, callback]
+      @db.append(self.to_goal, callback)
+    end
+
+    def to_goal
+      Goal.new(@pred.id, @pred.name, @args.map do |arg|
+        case arg
+        when TempClause
+          arg.to_goal
+        else
+          arg
+        end
+      end)
+    end
+
+    private
+
+    def list(*x)
+      y = nil
+      x.reverse_each {|e| y = Cons.new(e, y)}
+      return y
+    end
+  end
+
+  class Goal
+
+    attr_reader :pred_id, :pred_name, :args
+
+    def initialize(pred_id, pred_name, args)
+      @pred_id, @pred_name, @args = pred_id, pred_name, args
     end
 
     def inspect
-      return @pred.inspect.to_s + @args.inspect.to_s
+      return @pred_name.to_s + @args.inspect.to_s
     end
 
+    def to_prolog
+      args_out = @args.map do |arg|
+        case arg
+        when Symbol
+          if arg == :_
+            "_"
+          elsif /[[:upper:]]/.match(arg.to_s[0])
+            arg.to_s
+          else
+            "_#{arg.to_s}"
+          end
+        when String
+          "'#{arg}'"
+        when Cons, Goal
+          arg.to_prolog
+        when Numeric
+          arg.to_s
+        else
+          raise "Unknown argument: #{arg.inspect}"
+        end
+      end.join(', ')
+
+      if @pred_name == :not_
+        "\\+ #{args_out}"
+      else
+        "#{@pred_name}(#{args_out})"
+      end
+    end
   end
 
 
@@ -86,6 +157,19 @@ module RubyProlog
       return '(' + repr[self].join(' ') + ')'
     end
 
+    def to_prolog
+      current = self
+      array = []
+      while current
+        array << case current[0]
+          when :CUT then '!'
+          when :_ then '_'
+          else current[0].to_prolog
+          end
+        current = current[1]
+      end
+      return array.join(', ')
+    end
   end
 
 
@@ -111,6 +195,24 @@ module RubyProlog
       @table.clear
     end
 
+    def solution
+      @table.map do |var, env|
+        xp = env
+        loop {
+          x, x_env = xp
+          y, y_env = x_env.dereference(x)
+          next_xp = y_env.get(x)
+          if next_xp.nil?
+            xp = [y, y_env]
+            break
+          else
+            xp = next_xp
+          end
+        }
+        [var, xp[0]]
+      end.to_h
+    end
+
     def dereference(t)
       env = self
       while Symbol === t
@@ -124,32 +226,79 @@ module RubyProlog
     def [](t)
       t, env = dereference(t)
       return case t
-             when Goal then Goal.new(t.pred, env[t.args])
+             when Goal then Goal.new(t.pred_id, t.pred_name, 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 Database
+    attr_reader :by_name, :by_id
+
+    def initialize
+      @by_name = {}
+      @by_id = {}
+      @listing_enabled = false
+      @listing = {}
+    end
+
+    def register(pred_name, skip_listing: false)
+      pred = @by_name[pred_name] = Predicate.new(self, pred_name)
+      @by_id[pred.id] = pred
+      @listing[pred.id] = false if skip_listing
+      pred
+    end
+
+    def enable_listing(flag=true)
+      @listing_enabled = true
+    end
+
+    def append(head, body)
+      pred = @by_id[head.pred_id]
+      if pred.nil?
+        raise "No such predicate for head: #{head.inspect}"
+      end
+      pred.clauses << [head, body]
+      if @listing_enabled && @listing[pred.id] != false
+        # Ruby hashes maintain insertion order
+        @listing[pred.id] = true
+      end
+    end
+
+    def initialize_copy(orig)
+      super
+      @by_id = @by_id.transform_values do |pred|
+        pred.fork(self)
+      end
+      @by_name = @by_name.transform_values {|pred| @by_id[pred.id]}
+    end
+
+    def listing
+      @listing.select{|_,v| v}.map{|k,v| @by_id[k]}
+    end
   end
 
 
@@ -158,7 +307,9 @@ module RubyProlog
     def _unify(x, x_env, y, y_env, trail, tmp_env)
 
       loop {
-        if Symbol === x
+        if x == :_
+          return true
+        elsif Symbol === x
           xp = x_env.get(x)
           if xp.nil?
             y, y_env = y_env.dereference(y)
@@ -179,10 +330,10 @@ module RubyProlog
       }
 
       if Goal === x and Goal === y
-        return false unless x.pred == y.pred
+        return false unless x.pred_id == y.pred_id
         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| も可
@@ -201,8 +352,8 @@ module RubyProlog
       x.reverse_each {|e| y = Cons.new(e, y)}
       return y
     end
-    
-    
+
+
     def resolve(*goals)
       env = Environment.new
       _resolve_body(list(*goals), env, [false]) {
@@ -224,11 +375,7 @@ module RubyProlog
         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
+          for d_head, d_body in @db.by_id[goal.pred_id].clauses
             break if d_cut[0] or cut[0]
             trail = []
             if _unify_(goal, env, d_head, d_env, trail, d_env)
@@ -271,26 +418,21 @@ module RubyProlog
     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]]
+    def query(&block)
+      goals = instance_eval(&block)
+      goals = [goals] unless goals.is_a?(Array)
+      results = []
+
+      resolve(*goals.map(&:to_goal)) {|env|
+        results << env.solution
       }
-      # printout[goals] if count == 0
       return results
     end
-  
-  
+
+
     def is(*syms,&block)
       $is_cnt ||= 0
-      is = Predicate.new "IS_#{$is_cnt += 1}"
+      is = @db.register("IS_#{$is_cnt += 1}", skip_listing: true)
       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]})
@@ -300,46 +442,22 @@ module RubyProlog
     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.
+      pred = @db.register(meth)
+
+      # We only want to define the method on this specific object instance to avoid polluting global namespaces.
+      define_singleton_method(meth){ @db.by_name[meth] }
+
+      pred
+    end
 
-        return pred
+    def to_prolog
+      @db.listing.map(&:to_prolog).join("\n\n")
     end
 
-  
+
     def initialize
-      # We do not need to predefine predicates like this because they will automatically be defined for us.
-      # write = Predicate.new "write"
+      @db = Database.new
+      # These predicates are made available in all environments
       write[:X].calls{|env| print env[:X]; true}
       writenl[:X].calls{|env| puts env[:X]; true}
       nl[:X].calls{|e| puts; true}
@@ -358,8 +476,21 @@ module RubyProlog
         end
       end
       numeric[:X].calls{|env| Numeric === env[:X] }
+
+      not_[:X].calls do |env|
+        found_solution = false
+        resolve(env[:X], :CUT) { found_solution = true }
+        found_solution == false
+      end
+
+      # Enable here so the predicates above don't make it in to_prolog output
+      @db.enable_listing
     end
 
+    def initialize_copy(orig)
+      super
+      @db = @db.clone
+    end
   end
 
-end
+end

data/lib/ruby-prolog/version.rb

@@ -1,5 +1,5 @@
 module RubyProlog
 
-	VERSION = '1.0.1'
+	VERSION = '2.1.0'
 
 end

data/ruby-prolog.gemspec

@@ -8,17 +8,18 @@ Gem::Specification.new do |spec|
   spec.version       = RubyProlog::VERSION
   spec.authors       = ["Preston Lee"]
   spec.email         = ["preston.lee@prestonlee.com"]
-  spec.description   = "A Prolog-ish Ruby DSL."
+  spec.description   = "A pure Ruby implementation of a useful subset of Prolog."
   spec.summary       = "A Prolog-ish Ruby DSL."
   spec.homepage      = "http://github.com/preston/ruby-prolog"
-  spec.license       = "Apache 2"
+  spec.license       = "Apache-2.0"
 
   spec.files         = `git ls-files`.split($/)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "bundler", "~> 2"
+  spec.add_development_dependency "rake", "~> 13"
+  spec.add_development_dependency "minitest", "~> 5.14.0"
+  spec.add_development_dependency "minitest-focus", "~> 1.1.2"
 end

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

@@ -3,51 +3,114 @@ require_relative '../../test_helper'
 
 
 
-describe RubyProlog do  
-  
+describe RubyProlog do
+
   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.must_equal 0
-     end
-
-     two = RubyProlog::Core.new
-     two.instance_eval do
-       male[:preston].fact
-       query(male[:X]).length.must_equal 1
-     end
-     
-     three = RubyProlog::Core.new
-     three.instance_eval do
-       query(male[:X]).length.must_equal 0
-     end
-     
-     one.instance_eval do
-       query(male[:X]).length.must_equal 0
-     end
+    one = RubyProlog::Core.new
+    _( one.query{ male[:X] }.length ).must_equal 0
+
+    two = RubyProlog::Core.new
+    two.instance_eval do
+      male[:preston].fact
+    end
+    _( two.query{ male[:X] }.length ).must_equal 1
 
+    three = RubyProlog::Core.new
+    _( three.query{ male[:X] }.length ).must_equal 0
+
+    _( one.query{ male[:X] }.length ).must_equal 0
   end
-  
 
 
+  it 'returns hashes of solutions' do
+    one = RubyProlog.new do
+      foo['a', 'b'].fact
+      foo['a', 'b'].fact
+      foo['a', 'c'].fact
+      foo['d', 'e'].fact
+      foo['d', 'c'].fact
+    end
+    _( one.query {_= foo['a', :X] } ).must_equal [{ X: 'b' }, { X: 'b' }, { X: 'c' }]
+    _( one.query {_= foo['a', :X], foo['d', :X] } ).must_equal [{ X: 'c' }]
+    _(one.to_prolog.class).must_equal String
+  end
+
+  it 'works with numbers' do
+    one = RubyProlog.new do
+      foo[10, 20].fact
+      foo[10, 30].fact
+    end
+    _( one.query {_= foo[10, :X] } ).must_equal [{ X: 20 }, { X: 30 }]
+
+    _(one.to_prolog.class).must_equal String
+  end
+
+  it 'considers all predicates dynamic' do
+    one = RubyProlog::Core.new
+    one.instance_eval do
+      foo[10] << [bar[20]]
+    end
+    _( one.query {_= foo[:X] } ).must_equal []
+  end
+
+  it 'supports underscore' do
+    one = RubyProlog::Core.new
+    one.instance_eval do
+      foo[10, 200].fact
+      foo[10, 300].fact
+      foo[20, 400].fact
+
+      bar[50, :_].fact
+    end
+    _( one.query { foo[:X, :_] } ).must_equal [{X: 10}, {X: 10}, {X: 20}]
+    _( one.query { bar[50, 99] } ).must_equal [{}]
+    one.to_prolog
+  end
+
+  it 'supports clone' do
+    one = RubyProlog::Core.new
+    one.instance_eval do
+      foo[10].fact
+    end
+    _( one.query {_= foo[:X] } ).must_equal [{X: 10}]
+
+    two = one.clone
+    _( one.query {_= foo[:X] } ).must_equal [{X: 10}]
+    _( two.query {_= foo[:X] } ).must_equal [{X: 10}]
+
+    one.instance_eval{ foo[20].fact }
+
+    _( one.query {_= foo[:X] } ).must_equal [{X: 10}, {X: 20}]
+    _( two.query {_= foo[:X] } ).must_equal [{X: 10}]
+
+    two.instance_eval{ foo[30].fact }
+    _( one.query {_= foo[:X] } ).must_equal [{X: 10}, {X: 20}]
+    _( two.query {_= foo[:X] } ).must_equal [{X: 10}, {X: 30}]
+  end
+
   it 'should be able to query simple family trees.' do
 
-    c = RubyProlog::Core.new
-    c.instance_eval do
+    c = RubyProlog.new 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]]]
+      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, :C]]
+      ancestor[:A, :C] << [parent[:A, :X], parent[:X, :C]]
+
+      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
@@ -108,108 +171,137 @@ describe RubyProlog do
       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.must_equal 2
-      r[0][0].args[0].must_equal 'Matt'
-      r[1][0].args[0].must_equal 'Julie'
-      
-      # p "Who is married?"
-      # We defined 5 married facts.
-      query(married[:A, :B]).length.must_equal 5
-        
-      # p 'Are Karen and Julie siblings?'
-      # Yes, through two parents.
-      query(sibling['Karen', 'Julie']).length.must_equal 2
-      
-      
-      # p "Who likes to play games?"
-      # Four people.
-      query(interest[:X, 'Games']).length.must_equal 4
-      
-      
-      # p "Who likes to play checkers?"
-      # Nobody.
-      query(interest[:X, 'Checkers']).length.must_equal 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.must_equal 2
     end
 
+    # Runs some queries..
+
+    # p "Who are Silas's parents?"
+    # Silas should have two parents: Matt and Julie.
+    _( c.query{ parent[:P, 'Silas'] } ).must_equal [{P: 'Matt'}, {P: 'Julie'}]
+
+    # p "Who is married?"
+    # We defined 5 married facts.
+    _( c.query{ married[:A, :B] }.length ).must_equal 5
+
+    # p 'Are Karen and Julie siblings?'
+    # Yes, through two parents.
+    _( c.query{ sibling['Karen', 'Julie'] }.length ).must_equal 2
+
+
+    # p "Who likes to play games?"
+    # Four people.
+    _( c.query{ interest[:X, 'Games'] }.length ).must_equal 4
+
+
+    # p "Who likes to play checkers?"
+    # Nobody.
+    _( c.query{ interest[:X, 'Checkers'] }.length ).must_equal 0
+
+    # p "Who are Karen's ancestors?"
+    _( c.query{ ancestor[:A, 'Karen'] } ).must_equal [
+      {A: 'Marcia'},
+      {A: 'Ron'},
+      {A: 'Carol'},
+      {A: 'Kent'},
+      {A: 'Marge'},
+      {A: 'Pappy'},
+    ]
+
+    # p "What grandparents are also widowers?"
+    # Marge, twice, because of two grandchildren.
+    _( c.query{_= widower[:X], grandparent[:X, :G] }.length ).must_equal 2
+
+    _(c.to_prolog.class).must_equal String
   end
 
 
   it 'should be able to query simple family trees.' do
 
-    c = RubyProlog::Core.new
-    c.instance_eval do
+    c = RubyProlog.new 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'])
+
+      kind['laptop'].fact
+      kind['monitor'].fact
+      kind['phone'].fact
+
+      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], not_[vendor_of[:V, :K]]]
     end
-    
+
+    _( c.query{ is_a[:K, 'laptop'] }.length ).must_equal 2
+    _( c.query{ vendor_of[:V, 'phone'] } ).must_equal [{V: 'apple'}]
+    _( c.query{ not_vendor_of[:V, 'phone'] } ).must_equal [{V: 'dell'}]
+    _(c.to_prolog.class).must_equal String
   end
-  
-  
+
+
   it 'should solve the Towers of Hanoi problem.' do
-    c = RubyProlog::Core.new
-    c.instance_eval do
+    c = RubyProlog.new do
 
-      move[0,:X,:Y,:Z] <<= :CUT   # There are no more moves left
-      move[:N,:A,:B,:C] <<= [
+      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_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.must_equal 1
+       hanoi[:N] <<  move[:N,"left","right","center"]
+    end
+
+    _( c.query{ hanoi[5] } ).must_equal [{}]
+
+    _(c.to_prolog.class).must_equal String
+  end
+
+  it 'works on the other examples in the readme' do
+    db = RubyProlog.new do
+      implication['a', 'b'].fact
+      implication['b', 'c'].fact
+      implication['c', 'd'].fact
+      implication['c', 'x'].fact
+
+      implies[:A, :B] << implication[:A, :B]
+      implies[:A, :B] << [
+        implication[:A, :Something],
+        implies[:Something, :B]
+      ]
+    end
+
+    _( db.query{ implication['c', :X] } ).must_equal [{ X: 'd' }, { X: 'x' }]
+    _( db.query{ implication[:X, :_] } ).must_equal [{ X: 'a' }, { X: 'b' }, { X: 'c' }, { X: 'c' }]
+    _( db.query{_= implies['a', :X] } ).must_equal [{ X: 'b' }, { X: 'c' }, { X: 'd' }, { X: 'x' }]
 
-       # do_stuff[:STUFF].calls{|env| print env[:STUFF]; true}
+    _( db.query{[ implication['b', :S], implies[:S, :B] ]} ).must_equal [{:S=>"c", :B=>"d"}, {:S=>"c", :B=>"x"}]
+    _( db.query{_= implication['b', :S], implies[:S, :B] } ).must_equal [{:S=>"c", :B=>"d"}, {:S=>"c", :B=>"x"}]
 
-    end  
-    
+    # For good measure
+    _( db.query{_= implies['a', 'b'] } ).must_equal [{}]
+    _( db.query{_= implies['a', 'd'] } ).must_equal [{}]
+    _( db.query{_= implies['a', 'idontexist'] } ).must_equal []
   end
 end

data/test/test_helper.rb

@@ -1,3 +1,4 @@
 require 'minitest/autorun'
 require 'minitest/pride'
+require 'minitest/focus'
 require File.expand_path('../../lib/ruby-prolog.rb', __FILE__)

metadata

@@ -1,58 +1,72 @@
 --- !ruby/object:Gem::Specification
 name: ruby-prolog
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Preston Lee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-31 00:00:00.000000000 Z
+date: 2020-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '13'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 5.14.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
-description: A Prolog-ish Ruby DSL.
+        version: 5.14.0
+- !ruby/object:Gem::Dependency
+  name: minitest-focus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.2
+description: A pure Ruby implementation of a useful subset of Prolog.
 email:
 - preston.lee@prestonlee.com
 executables:
@@ -61,7 +75,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - NOTICE
 - README.md
@@ -76,7 +90,7 @@ files:
 - test/test_helper.rb
 homepage: http://github.com/preston/ruby-prolog
 licenses:
-- Apache 2
+- Apache-2.0
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -84,17 +98,16 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: A Prolog-ish Ruby DSL.