rbprolog 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 53b585062269fdd1b34299a6062ed17d194a24a0
-  data.tar.gz: 189dee03f4f9bf9d6af6ad3ab04a1b1a6f6b8b1a
+  metadata.gz: dda78e71e7f2217c87e9a9c52e81be412f3adc15
+  data.tar.gz: 281cf156ef8af5401c8f6365bd7e10f7345d093e
 SHA512:
-  metadata.gz: f268165d241aeaf52c27044b3a69c89a92ae4ad5380e1274189d01b6efbab70d117719ec7dd3c9ccf710fd353d64d17a7f0fa9437549cffc5461537029163965
-  data.tar.gz: d615a690017127e4a957412ce550b2beaf832f3a97d0ccb48a80c810b5672ee1b37bd5ea431fbbdc646ada966daaf8583b2043468cb8f17f9f5d87b25adf4048
+  metadata.gz: 70aab09d55abbe7a3ce29d0ceabd55dd149ed3cae2395dd16a038c17de64ec15ebcd7a3f3ddfed2fd4d73dab2a92d9304206ade6bf0aa900d9d010e9718337eb
+  data.tar.gz: 441e56975d5aecb431d0aa39801734052949e88a0ea4806d1d7b8a7f0d19ec32c99700d85ab19a0767dd5c2034d7e9342616f504013cd2fb9ce825608aa14093

data/lib/rbprolog/context.rb

@@ -2,6 +2,11 @@ module Rbprolog
   class Context
     attr_accessor :binds
 
+    def initialize
+      @scopes = []
+      @binds = {}
+    end
+
     def match?(v1, v2)
       v1 = deduce(v1)
       Var === v1 || Var === v2 || v1 == v2
@@ -16,10 +21,18 @@ module Rbprolog
       end
     end
 
+    def [](sym)
+      @binds[sym]
+    end
+
+    def []=(sym, value)
+      @binds[sym] = value
+    end
+
     def deduce(v)
       if Var === v
         unless @binds[v.sym]
-          @stacks.last << v.sym
+          @scopes.last << v.sym
           @binds[v.sym] = Var.new(v.sym)
         end
 
@@ -30,16 +43,13 @@ module Rbprolog
     end
 
     def scope(predicate, &block)
-      @stacks ||= []
-      @stacks.push([])
-
-      @binds ||= {}
+      @scopes.push([])
 
       mirror = @binds.clone
 
-      result = yield
+      result = yield predicate.args.map {|arg| self.deduce(arg)}
 
-      @stacks.pop.each {|bind| @binds.delete bind}
+      @scopes.pop.each {|bind| @binds.delete bind}
       @binds.merge!(mirror)
 
       result

data/lib/rbprolog/deduction.rb

@@ -1,35 +1,24 @@
 module Rbprolog
   class Deduction
-    include Enumerable
-
     attr_accessor :args, :sym
 
-    def initialize(logic, sym, *args)
-      @logic = logic
+    def initialize(sym, *args)
       @sym = sym
-
       @args = args
     end
 
-    def each
-      each_deduce(Context.new, @logic.rules, []) do |hash|
-        yield hash
-      end
-    end
-
     def each_deduce(context, rules, id)
-      print "#{"\t" * id.size}#{id.join('.')} #{@sym}?(#{@args.map(&:to_s).join(', ')})"
+      print "#{"\t" * id.size}#{id.join('.')} #{@sym}?(#{@args.join(', ')})"
 
-      rules.select {|rule| rule.sym == @sym}.each_with_index do |rule, i|
-        context.scope(self) do
-          puts " => #{@sym}?(#{@args.map {|arg| context.deduce(arg).to_s}.join(', ')})" if i == 0
+      rules.select {|rule| rule.sym == @sym}.each_with_index do |rule, rule_index|
+        context.scope(self) do |scoped_args|
+          puts " => #{@sym}?(#{scoped_args.join(', ')})" if rule_index == 0
 
-          rule.each_deduce(rules, *@args.map {|arg| context.deduce(arg)}, id + [i]) do |hash|
+          rule.each_match(rules, *scoped_args, id + [rule_index]) do |hash|
             context.scope(self) do
               rule.args.each_with_index do |rule_arg, rule_arg_index|
-                deduced_arg = context.deduce(@args[rule_arg_index])
-                if Var === deduced_arg
-                  context.binds[deduced_arg.sym] = Var === rule_arg ? hash[rule_arg.sym] : rule_arg
+                if Var === scoped_args[rule_arg_index]
+                  context[scoped_args[rule_arg_index].sym] = Var === rule_arg ? hash[rule_arg.sym] : rule_arg
                 end
               end
 

data/lib/rbprolog/rule.rb

@@ -10,13 +10,13 @@ module Rbprolog
       @deductions = [deductions].flatten
     end
 
-    def each_deduce(rules, *args, id)
-      print "#{"\t" * id.size}#{id.join('.')} #{@sym}(#{@args.map(&:to_s).join(', ')}).deduce(#{args.map(&:to_s).join(', ')})"
+    def each_match(rules, *args, id)
+      print "#{"\t" * id.size}#{id.join('.')} #{@sym}(#{@args.join(', ')}).deduce(#{args.join(', ')})"
 
       context = Context.new
-      context.scope(self) do
+      context.scope(self) do |scoped_args|
         if self.match!(context, args)
-          puts " => #{@sym}(#{@args.map {|arg| context.deduce(arg).to_s}.join(', ')})" #{context.to_s} #{context.binds.inspect}"
+          puts " => #{@sym}(#{@args.map {|arg| context.deduce(arg)}.join(', ')})"
           deduce_deductions(context, rules, *@deductions, id) do
             yield context.binds
           end
@@ -41,17 +41,17 @@ module Rbprolog
       if deductions.empty?
         yield
       else
-        predicate = deductions.shift
-        if Deduction === predicate
-          predicate.each_deduce(context, rules, id + [@deductions.size - deductions.size - 1]) do |hash|
+        deduction = deductions.shift
+        if Deduction === deduction
+          deduction.each_deduce(context, rules, id + [@deductions.size - deductions.size - 1]) do |hash|
             deduce_deductions(context, rules, *deductions, id, &block)
           end
         else
           @logic.send(:define_singleton_method, :const_missing) do |sym|
-            context.binds[sym]
+            context[sym]
           end
 
-          predicate.call && deduce_deductions(context, rules, *deductions, id, &block)
+          deduction.call && deduce_deductions(context, rules, *deductions, id, &block)
         end
 
       end

data/lib/rbprolog/version.rb

@@ -1,3 +1,3 @@
 module Rbprolog
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/lib/rbprolog.rb

@@ -7,18 +7,23 @@ require_relative 'rbprolog/var'
 module Rbprolog
   def self.included(mod)
     class << mod
-      attr_accessor :rules, :syms
-
       include ClassMethods
+      attr_accessor :rules, :syms
     end
   end
 
-  def initialize(&block)
-    instance_eval(&block) if block
+  def initialize(string = nil, &block)
+    if string || block
+      self.extend(Rbprolog)
+
+      self.singleton_class.keywords(*self.class.syms)
+      self.singleton_class.class_eval(string) if string
+      self.singleton_class.class_eval(&block) if block
+    end
   end
 
   def rules
-    self.class.rules + (@rules || [])
+    self.class.rules + (self.singleton_class.rules || [])
   end
 
   module ClassMethods
@@ -37,7 +42,7 @@ module Rbprolog
       if self.syms.include? sym
         Hash === args.last ? rule(sym, *args) : rule(sym, *args, :if => [])
       elsif self.syms.include? sym.to_s.chomp('?').to_sym
-        Deduction.new(self, sym.to_s.chomp('?').to_sym, *args)
+        Deduction.new(sym.to_s.chomp('?').to_sym, *args)
       else
         super
       end
@@ -48,14 +53,19 @@ module Rbprolog
       self.rules << Rule.new(sym, *args, options[:if])
 
       unless method_defined?(sym)
-        #FIXME only allow fact for now
-        define_method(sym) do |*args|
-          @rules ||= []
-          @rules << Rule.new(sym, *args, [])
-        end
-
         define_method("#{sym}!") do |*args|
-          Deduction.new(self, sym, *args)
+          deduction = Deduction.new(sym, *args)
+
+          deduction.extend(Enumerable)
+
+          rules = self.rules
+          deduction.define_singleton_method(:each) do |&block|
+            each_deduce(Context.new, rules, []) do |hash|
+              block.call hash
+            end
+          end
+
+          deduction
         end
 
         define_method("#{sym}?") do |*args|

data/rbprolog.gemspec

@@ -18,8 +18,6 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.metadata = { "Source Code" => "https://github.com/rli9/rbprolog" }
-
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
 end

data/test/test_rbprolog.rb

@@ -37,6 +37,26 @@ class TestRbprolog < Test::Unit::TestCase
     assert_equal ['p1', 'p2', 'p3', 'p4'], l.friends!('p1', Rbprolog::Var.new(:W)).map {|hash| hash[:W]}.uniq.sort
   end
 
+  def test_logic_instance_should_allow_new_fact
+    l = FriendLogic.new do
+      likes 'p5', 's1'
+    end
+
+    assert_equal true, l.likes?('p5', 's1')
+    assert_equal false, l.likes?('p5', 's2')
+    assert_equal true, l.friends?('p5', 'p3')
+    assert_equal false, l.friends?('p5', 'p2')
+  end
+
+  def test_logic_instance_should_allow_new_rule
+    l = FriendLogic.new %q{
+      friends 'p2', X, :if => likes?(X, 's1')
+    }
+
+    assert_equal true, l.friends?('p2', 'p3')
+    assert_equal true, l.friends?('p2', 'p1')
+  end
+
   def test_logic_instances_should_be_independent
     l1 = FriendLogic.new do
       likes 'p5', 's1'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbprolog
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Ruijia Li
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-29 00:00:00.000000000 Z
+date: 2013-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -61,8 +61,7 @@ files:
 homepage: https://github.com/rli9/rbprolog
 licenses:
 - MIT
-metadata:
-  Source Code: https://github.com/rli9/rbprolog
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths: