omf_rete 0.5 → 0.6.1

data/lib/omf_rete/tuple_stream.rb

@@ -1,16 +1,17 @@
 
+require 'omf_rete/tuple'
 
 module OMF::Rete
   #
-  # This class provides functionality to process a 
-  # stream of tuples. 
+  # This class provides functionality to process a
+  # stream of tuples.
   #
   class AbstractTupleStream
     attr_accessor :source
     attr_reader :description
-    
+
     def initialize(description, source = nil)
-      @description = description 
+      @description = description
       @source = source
     end
 
@@ -19,14 +20,14 @@ module OMF::Rete
         el == bname
       end
     end
-    
+
     # Return true if +tuple+ can be produced by this stream through the
     # normal (+addTuple+) channels.
     #
     def check_for_tuple(tuple)
       raise "Method 'check_for_tuple' is not implemented"
     end
-    
+
     def describe(out = STDOUT, offset = 0, incr = 2, sep = "\n")
       out.write(" " * offset)
       _describe(out, sep)
@@ -45,7 +46,7 @@ module OMF::Rete
   #
   class ProcessingTupleStream < AbstractTupleStream
     attr_accessor :receiver
-    
+
     def initialize(project_pattern, out_description = project_pattern, in_description = nil, receiver = nil, &block)
       @project_pattern = project_pattern
       super out_description
@@ -54,33 +55,33 @@ module OMF::Rete
         self.inDescription = in_description
       end
       @receiver = receiver
-      @block = block
+      @on_add_block = block
     end
-    
+
     def on_add(&block)
-      @block = block
+      @on_add_block = block
     end
-    
+
+    def on_remove(&block)
+      @on_remove_block = block
+    end
+
     def addTuple(tuple)
-      if @result_map
-        rtuple = @result_map.collect do |i| tuple[i] end
-      else
-        rtuple = tuple
+      if (result = process(tuple, @on_add_block))
+        @receiver.addTuple(result)
       end
-      result = @block ? @block.call(*rtuple) : rtuple
-#        if @block
-#          if (out = @block.call(*rtuple))
-#            unless out.kind_of?(Array) && out.size == @result_size
-#              raise "Expected block to return an array of size '#{@result_size}', but got '#{out.inspect}'"
-#            end
-#            @receiver.addTuple(out)
-#          end
-#        else
-#          @receiver.addTuple(rtuple)
-#        end    
-      process_result(result, tuple)
-    end    
-    
+    end
+
+    def removeTuple(tuple)
+      if (result = process(tuple, @on_remove_block))
+        @receiver.removeTuple(result)
+      end
+    end
+
+    def clear()
+      @receiver.clear
+    end
+
     def source=(source)
       super
       if source
@@ -99,18 +100,30 @@ module OMF::Rete
         end
       end
     end
-    
+
     private
-    
-    def process_result(result, original_tuple)
+
+    def process(tuple, block)
+      if @result_map
+        rtuple = @result_map.collect do |i| tuple[i] end
+      else
+        rtuple = tuple
+      end
+      result = block ? block.call(*rtuple) : rtuple
       if (result)
-        unless result.kind_of?(Array) && result.size == @result_size
-          raise "Expected block to return an array of size '#{@result_size}', but got '#{result.inspect}'"
-        end
-        @receiver.addTuple(result)
+        result = verify_result(result, tuple)
       end
+      result
     end
-    
+
+    def verify_result(result, original_tuple)
+      unless result.kind_of?(Array) && result.size == @result_size
+        raise "Expected block to return an array of size '#{@result_size}', but got '#{result.inspect}' - #{block}"
+      end
+      result
+    end
+
+
     def _describe(out, sep )
       out.write("processing#{sep}")
     end
@@ -121,7 +134,7 @@ module OMF::Rete
   # for every incoming tuple.
   #
   # TODO: This should really be a subclass of +ProcessingTupleStream+, but
-  # we have supress_duplicates in this class which may be useful for 
+  # we have supress_duplicates in this class which may be useful for
   # +ProcessingTupleStream+ as well.
   #
   class ResultTupleStream < AbstractTupleStream
@@ -133,7 +146,7 @@ module OMF::Rete
         @results = Set.new
       end
     end
-    
+
     def source=(source)
       @source = source
       if @source.description != @description
@@ -146,36 +159,55 @@ module OMF::Rete
         end
       end
     end
-    
+
     def addTuple(tuple)
       if @result_map
-        rtuple = @result_map.collect do |i| tuple[i] end
+        ta = @result_map.collect do |i| tuple[i] end
       else
-        rtuple = tuple
+        ta = tuple
       end
+      rtuple = Tuple.new(ta, @description)
       if @results
-        if @results.add?(rtuple)
-          @block.call(rtuple)
+        if @results.add?(ta)
+          @block.arity == 1 ? @block.call(rtuple) : @block.call(rtuple, :add)
         end
       else
-        @block.call(rtuple)          
+        @block.arity == 1 ? @block.call(rtuple) : @block.call(rtuple, :add)
+      end
+    end
+
+    def removeTuple(tuple)
+      if @result_map
+        ta = @result_map.collect do |i| tuple[i] end
+      else
+        ta = tuple
+      end
+      rtuple = Tuple.new(ta, @description)
+      if @results
+        @results.delete(ta)
       end
+      @block.arity == 1 ? @block.call(rtuple) : @block.call(rtuple, :remove)
     end
-    
+
+    def clear()
+      @results.clear if @results
+      @block.call(nil, :cleared) if @block.arity == 2
+    end
+
     # Return true if +tuple+ can be produced by this stream. A
     # +ResultStream+ only narrows a stream, so we need to
     # potentially expand it (with nil) and pass it up to the
     # +source+ of this stream.
     #
     def check_for_tuple(tuple)
-      if @sourcce 
+      if @sourcce
         # should check if +tuple+ has the same size as description
         if @result_map
           # need to expand
           unless @expand_map
             @expand_map = @source.description.collect do |name|
               index = @description.find_index do |n2| name == n2 end
-            end              
+            end
           end
           up_tuple = @expand_map.collect do |i| i nil? ? nil : tuple[i] end
         else
@@ -186,14 +218,14 @@ module OMF::Rete
     end
 
     private
-    
+
     def _describe(out, sep )
       out.write("out: [#{@description.join(', ')}]#{sep}")
     end
   end # ResultTupleStream
 
   # A filtering tuple stream calls the associated processing block
-  # for every incoming tuple and forwards the incoming tuple if the 
+  # for every incoming tuple and forwards the incoming tuple if the
   # the block returns true, otherwise it drops the tuple.
   #
   class FilterTupleStream < ProcessingTupleStream
@@ -201,7 +233,7 @@ module OMF::Rete
     def initialize(project_pattern, description = project_pattern, receiver = nil, &block)
       super project_pattern, description, description, receiver, &block
     end
-    
+
     # Return true if +tuple+ can be produced by this stream. For
     # this we need to check first if it would pass this filter
     # before we check if the source for this filter is being
@@ -210,7 +242,7 @@ module OMF::Rete
     # TODO: This currently doesn't work for tuples with wild cards.
     #
     def check_for_tuple(tuple)
-      if @sourcce 
+      if @sourcce
         # should check if +tuple+ has the same size as description
         if @result_map
           rtuple = @result_map.collect do |i| tuple[i] end
@@ -222,16 +254,13 @@ module OMF::Rete
         end
       end
     end
-    
+
     private
-    
-    def process_result(result, original_tuple)
-      if (result)
-        @receiver.addTuple(original_tuple)
-      end
+
+    def verify_result(decision, original_tuple)
+      decision ? original_tuple : nil
     end
-    
-    
+
     def _describe(out, sep )
       out.write("filtering#{sep}")
     end

data/lib/omf_rete/version.rb

@@ -1,7 +1,7 @@
 
 module OMF
   module Rete
-    VERSION = '0.5'
+    VERSION = '0.6.1'
     # Used for finding the example directory
     TOP_DIR = File.dirname(File.dirname(File.dirname(__FILE__)))
   end

data/lib/omf_rete.rb

@@ -3,7 +3,17 @@
 
 module OMF
   module Rete
-    
+
+    # Create a Rete engine to operate on.
+    #
+    # @param opts :tuple_length Length of tuple if only one type is used
+    #
+    def self.create_engine(opts = {})
+      require 'omf_rete/store'
+      Store.create(opts.delete(:tuple_length), opts)
+
+    end
+
     # Defines a filter on a tuple stream. The argument is either a variable
     # number of binding variables with which the associated block is called.
     # If the argument are two arrays, the first one holds the above described
@@ -16,15 +26,15 @@ module OMF
         if projectPattern.size != 2
           raise "Wrong arguments for 'filter'. See documentation."
         end
-        outDescription = projectPattern[1] 
-        projectPattern = projectPattern[0] 
+        outDescription = projectPattern[1]
+        projectPattern = projectPattern[0]
       else
         outDescription = nil
       end
 
       FilterPlan.new(projectPattern, outDescription, &block)
     end
-    
+
     def self.differ(binding1, binding2)
       filter(binding1, binding2) do |b1, b2|
         b1 != b2

data/omf_rete.gemspec

@@ -21,4 +21,7 @@ Gem::Specification.new do |s|
 
   # specify any dependencies here; for example:
 #  s.add_development_dependency "minitest", "~> 2.11.3"
+
+  s.add_runtime_dependency "omf_base"
+
 end

data/tests/test_filter.rb

@@ -20,7 +20,7 @@ class TestFilter < Test::Unit::TestCase
 
     resT = []
     result = pb.materialize(outPattern) do |t|
-      resT << t
+      resT << t.to_a
     end
       
     out = StringIO.new

data/tests/test_join_op.rb

@@ -47,4 +47,34 @@ class TestJoinOP < Test::Unit::TestCase
     r.addTuple(t2)
     assert_equal [['x', 'y', 'z']], out.to_a
   end
+  
+  # [:a :x?], [?x :c]
+  #
+  def test_remove1
+    t1 = ['a', 'b']
+    t2 = ['b', 'd']
+    t3 = ['b', 'e']    
+    l = OMF::Rete::IndexedTupleSet.new([:a, :x?], [:x?])
+    r = OMF::Rete::IndexedTupleSet.new([:x?, :b], [:x?])
+    out = IndexedTupleSet.new([:x?], [:x?])
+    JoinOP.new(l, r, out)
+    l.addTuple(t1)
+    r.addTuple(t2)
+    assert_equal [[t1[1]]], out.to_a
+
+    l.removeTuple(t1)
+    assert_equal [], out.to_a
+
+    l.addTuple(t1)
+    r.addTuple(t3)
+    #assert_equal [[t1[1]]], out.to_a
+    assert_equal [['b']], out.to_a
+
+    r.removeTuple(t3)
+    assert_equal [['b']], out.to_a
+    r.removeTuple(t2)
+    assert_equal [], out.to_a
+
+  end
+  
 end

data/tests/test_named_store.rb

@@ -0,0 +1,36 @@
+require 'omf_rete/store'
+
+include OMF::Rete
+
+class TestNamedStore < Test::Unit::TestCase
+
+  def create_store()
+    Store.create(3, type: :named_alpha, name: :foo)
+  end
+
+  def test_create_store
+    store = create_store()
+  end
+
+  def test_add_tuple
+    store = create_store()
+    store.addTuple [:foo, :b, :c]
+  end
+
+  def test_add_tuple2
+    store = create_store()
+    store.add :foo, :b, :c
+  end
+
+  def test_add_wrong_named_tuple
+    store = create_store()
+    assert_raise OMF::Rete::Store::WrongNameException do
+      store.add :a, :b, :c
+    end
+  end
+
+
+end
+
+
+

data/tests/test_object_store.rb

@@ -0,0 +1,150 @@
+require 'omf_rete/store'
+
+include OMF::Rete
+
+class TestObjectStore < Test::Unit::TestCase
+
+  class Obj
+    attr_accessor :a, :b
+
+    def initialize(a, b = nil)
+      self.a = a; self.b = b
+    end
+  end
+
+  class User
+    attr_accessor :name
+
+    def initialize(name)
+      self.name = name
+    end
+  end
+
+  def create_store(opts = {})
+    Store.create(0, opts.merge(type: :object))
+  end
+
+  def test_create_store
+    store = create_store()
+  end
+
+  def test_add_tuple_to_empty
+    store = create_store()
+    assert_raise OMF::Rete::Store::NotImplementedException do
+      store.add :a
+    end
+  end
+
+  def test_find_single
+    store = create_store()
+    store.representObject(Obj.new(1))
+    assert_equal Set.new([[:a, 1]]), store.find([:a, nil])
+  end
+
+  def test_find_single2
+    store = create_store(name: :p)
+    store.representObject(Obj.new(1))
+    assert_equal Set.new([[:p, :a, 1]]), store.find([:p, :a, nil])
+  end
+
+  def test_find_enumerable
+    store = create_store()
+    store.representObject(Obj.new([1,2]))
+    assert_equal Set.new([[:a, 1], [:a, 2]]), store.find([:a, nil])
+  end
+
+  def test_find_validate
+    store = create_store()
+    store.representObject(Obj.new(1))
+    assert_equal Set.new([[:a, 1]]), store.find([:a, 1])
+    assert_equal Set.new([]), store.find([:a, 2])
+  end
+
+  def test_find_validate_enumerable
+    store = create_store()
+    store.representObject(Obj.new([1,2]))
+    assert_equal Set.new([[:a, 1]]), store.find([:a, 1])
+  end
+
+  def test_tset
+    store = create_store()
+    store.representObject(Obj.new(1))
+    tset = store.createTSet([:a, :x?], [:x?])
+    assert_equal Set.new([[:a, 1]]), tset.to_set
+  end
+
+  def test_tset2
+    store = create_store(name: :p)
+    store.representObject(Obj.new(1))
+    tset = store.createTSet([:p, :a, :x?], [:x?])
+    assert_equal Set.new([[:p, :a, 1]]), tset.to_set
+  end
+
+  def test_change_object_tset
+    store = create_store()
+    store.representObject(Obj.new(1))
+    tset = store.createTSet([:a, :x?], [:x?])
+    store.representObject(Obj.new(2))
+    assert_equal Set.new([[:a, 2]]), tset.to_set
+  end
+
+  def test_change_object_subscribe
+
+    store = create_store()
+    store.representObject(Obj.new(1))
+
+    plan = [[:a, :x?]]
+
+    resT = Set.new
+    actionSet = Set.new
+    result = store.subscribe(:test, plan) do |t, a|
+      (resT << t.to_a) if a == :add
+      actionSet << a
+    end
+    assert_equal Set.new([[1]]), resT
+    assert_equal Set.new([:add]), actionSet
+
+    # Now lets change the object
+    resT.clear; actionSet.clear
+    store.representObject(Obj.new(2))
+    assert_equal Set.new([[2]]), resT
+    assert_equal Set.new([:cleared, :add]), actionSet
+  end
+
+  def test_change_object_subscribe_two_stores
+
+    store = Store.create(0, type: :predicate)
+
+    as_store = store.registerPredicate(:as, 3)
+    store.add :as, :userA, :ok
+
+    msg_store = Store.create(0, type: :object, name: :m)
+    store.registerPredicateStore(:m, msg_store)
+
+    plan = [[:m, :name, :n?], [:as, :n?, :y?]]
+
+    resT = Set.new
+    actionSet = Set.new
+    result = store.subscribe(:test, plan) do |t, a|
+      (resT << t.to_a) if a == :add
+      actionSet << a
+    end
+
+    msg_store.representObject(User.new(:userA))
+
+    assert_equal Set.new([[:m, :name, :userA]]), store.find([:m, :name, nil])
+    assert_equal Set.new([[:as, :userA, :ok]]), store.find([:as, nil, nil])
+    assert_equal Set.new([[:userA, :ok]]), resT
+    assert_equal Set.new([:cleared, :add]), actionSet
+
+    # Now lets change the object
+    resT.clear; actionSet.clear
+    msg_store.representObject(User.new(:userB))
+    assert_equal Set.new(), resT
+    assert_equal Set.new([:cleared]), actionSet
+  end
+
+end
+
+
+