omf_rete 0.5 → 0.6.1

data/tests/test_planner.rb

@@ -8,42 +8,41 @@ include OMF::Rete
 include OMF::Rete::Planner
 
 class TestPlanner < Test::Unit::TestCase
-  
+
   def test_create_plan_builder
     plan = [[:x?, :b, :c]]
     store = Store.create(3)
     pb = PlanBuilder.new(plan, store)
   end
-  
+
   def _test_plan(plan, storeSize, expected = nil, inTuples = nil, outTuples = nil, outPattern = nil)
     store = Store.create(storeSize)
 
-    # pb = PlanBuilder.new(plan, store)
-    # pb.build
-    # #pb.describe
-    # resT = []
-    # result = pb.materialize(outPattern) do |t|
-      # resT << t
-    # end
-    
+    # with empty store
     resT = []
     result = store.subscribe(:test, plan, outPattern) do |t|
-      resT << t
+      resT << t.to_a
     end
-    
-      
+
     out = StringIO.new
     #result.describe(out, 0, 0, '|')
     result.describe(out)
     assert_equal(expected, out.string) if expected
-    
+
     if (inTuples)
+
       inTuples.each do |t|
         store.addTuple(t)
       end
       assert_equal(outTuples, resT)
+
+      # same test with already full store
+      resT2 = []
+      result2 = store.subscribe(:test2, plan, outPattern) do |t|
+        resT2 << t.to_a
+      end
+      assert_equal(outTuples, resT2)
     end
-    result
   end
 
   def test_build_simple_plan
@@ -56,7 +55,7 @@ out: [x?]
     resT = [[:a]]
     _test_plan plan, 3, exp, inT, resT
   end
-  
+
   def test_build_simple_plan_loaded
     plan = [[:x?, :b, :c]]
     exp = %{\
@@ -68,7 +67,7 @@ out: [x?]
     _test_plan plan, 3, exp, inT, resT
   end
 
-  
+
   def test_project
     plan = [[:x?, :b, :y?]]
     exp = %{\
@@ -79,7 +78,7 @@ out: [y?]
     resT = [[:c], [:e]]
     _test_plan plan, 3, exp, inT, resT, [:y?]
   end
-  
+
   def test_simple_project
     plan = [[:x?, :b, :y?]]
     exp = %{\
@@ -90,7 +89,7 @@ out: [y?]
     resT = [[:c], [:e]]
     _test_plan plan, 3, exp, inT, resT, [:y?]
   end
-  
+
   def test_simple_project2
     plan = [[:x?, :b, :y?]]
     exp = %{\
@@ -101,7 +100,7 @@ out: [x?]
     resT = [[:a], [:d]]
     _test_plan plan, 3, exp, inT, resT, [:x?]
   end
-  
+
   def test_simple_project3
     plan = [[:x?, :b, :y?]]
     exp = %{\
@@ -121,11 +120,14 @@ out: [x?]
 }
     inT = [[:a, :b, :c], [:d, :b, :e]]
     resT = [[:a]]
-    _test_plan plan, 3, exp, inT, resT
+    assert_raise OMF::Rete::Planner::NoBindingException do
+      #_test_plan plan, 3, exp, inT, resT
+      _test_plan plan, 3, nil, nil, nil
+    end
   end
-  
+
   def test_build_single_join
-    plan = [[:x?, :b, :c], [:x?, :b, :d]]    
+    plan = [[:x?, :b, :c], [:x?, :b, :d]]
     exp = %{\
 out: [x?]
   join: [x?] => [x?]
@@ -136,9 +138,9 @@ out: [x?]
     resT = [[:a]]
     _test_plan plan, 3, exp, inT, resT
   end
-  
+
   def test_build_single_join_with_project
-    plan = [[:x?, :b, :y?], [:x?, :y?, :d]]    
+    plan = [[:x?, :b, :y?], [:x?, :y?, :d]]
     exp = %{\
 out: [y?]
   join: [x?, y?] => [y?]
@@ -151,7 +153,7 @@ out: [y?]
   end
 
   def test_build_single_join_with_project2
-    plan = [[:x?, :b, :y?], [:x?, :y?, :d]]    
+    plan = [[:x?, :b, :y?], [:x?, :y?, :d]]
     exp = %{\
 out: [y?, x?]
   join: [x?, y?] => [x?, y?]
@@ -165,9 +167,9 @@ out: [y?, x?]
 
 
   def test_build_two_joins
-    plan = [[:x?, :b, :c], 
+    plan = [[:x?, :b, :c],
             [:y?, :d, nil],
-            [:x?, :e, :y?]]    
+            [:x?, :e, :y?]]
     exp = %{\
 out: [x?, y?]
   join: [y?] => [x?, y?]
@@ -184,10 +186,10 @@ out: [x?, y?]
   end
 
   def test_build_three_joins
-    plan = [[:x?, :a, :b], 
+    plan = [[:x?, :a, :b],
             [:y?, :c, :d],
             [:x?, :e, :z?],
-            [:z?, :f, :y?]]    
+            [:z?, :f, :y?]]
     exp = %{\
 out: [x?, y?, z?]
   join: [z?] => [x?, y?, z?]
@@ -204,29 +206,59 @@ out: [x?, y?, z?]
     resT = [[:x, :y, :z]]
     _test_plan plan, 3, exp, inT, resT
   end
-  
+
 
   def test_siblings
-    store = Store.create(3)    
+    store = Store.create(3)
     store.addTuple([:a, :hasParent, :p])
     store.addTuple([:b, :hasParent, :p])
 
     resT = Set.new
-    store.query([[:x?, :sibling_of, :y?]]) do |t|
-      resT << t
+    store.subscribe(:r1, [[:x?, :sibling_of, :y?]]) do |t|
+      resT << t.to_a
     end
     assert_equal(Set.new, resT)
-    
+
     subscription = [
-      [:x?, :hasParent, :p?], 
+      [:x?, :hasParent, :p?],
       [:y?, :hasParent, :p?],
-      OMF::Rete.differ(:x?, :y?) 
+      OMF::Rete.differ(:x?, :y?)
     ]
-    store.query(subscription, [:x?, :y?]) do |x, y|
-      store.addTuple([x, :sibling_of, y])
+    store.subscribe(:r2, subscription, [:x?, :y?]) do |t|
+      store.addTuple([t[:x?], :sibling_of, t[:y?]])
     end
 
     assert_equal(Set.new([[:b, :a], [:a, :b]]), resT)
-    
+
+  end
+
+  def test_remove
+    store = Store.create(2)
+
+    # with empty store
+    resT = []
+    plan = [[nil, :x?], [:x?, nil]]
+    result = store.subscribe(:test, plan) do |t, action|
+      #puts "#{action}: #{t.to_a.inspect}"
+      action == :add ? resT << t.to_a : resT.delete(t.to_a)
+    end
+    #result.describe()
+    store.add(:a, :b)
+    store.add(:b, :c)
+    assert_equal([[:b]], resT)
+
+    store.remove(:a, :b)
+    assert_equal([], resT)
+
+    store.add(:a, :b)
+    store.add(:d, :b)
+    assert_equal([[:b]], resT)
+
+    store.remove(:a, :b)
+    assert_equal([[:b]], resT)
+
+    store.remove(:d, :b)
+    assert_equal([], resT)
+    #store.addTuple(:a, :b)
   end
 end

data/tests/test_predicate_store.rb

@@ -0,0 +1,95 @@
+require 'omf_rete/store'
+
+include OMF::Rete
+
+class TestPredicateStore < Test::Unit::TestCase
+
+  def create_store()
+    Store.create(0, type: :predicate)
+  end
+
+  def test_create_store
+    store = create_store()
+  end
+
+  def test_add_tuple_to_empty
+    store = create_store()
+    assert_raise OMF::Rete::Store::UnknownPredicateException do
+      store.add :foo, :b, :c
+    end
+  end
+
+  def test_add_tuple_one_predicate
+    store = create_store()
+    store.registerPredicate(:foo, 3)
+    store.add :foo, :b, :c
+  end
+
+  def test_add_tuple_tow_predicates
+    store = create_store()
+    store.registerPredicate(:foo, 3)
+    store.registerPredicate(:goo, 4)
+    store.add :foo, :b, :c
+    store.add :goo, :b, :c, :d
+  end
+
+  def test_find
+    tuples = [[:p1, :b, :c1],
+              [:p1, :b, :c2],
+              [:p2, :f1],
+              [:p2, :f2]
+             ]
+
+    store = create_store()
+    store.registerPredicate(:p1, 3)
+    store.registerPredicate(:p2, 2)
+
+    tuples.each {|t| store.addTuple t }
+
+    r = store.find tuples[0]
+    assert_equal Set.new([tuples[0]]), r
+    r = store.find [:p1, :b, nil]
+    assert_equal Set.new([tuples[0], tuples[1]]), r
+
+    r = store.find tuples[2]
+    assert_equal Set.new([tuples[2]]), r
+    r = store.find [:p2, nil]
+    assert_equal Set.new([tuples[2], tuples[3]]), r
+  end
+
+  def test_find_tuple_exceptions
+    store = create_store()
+    assert_raise OMF::Rete::Store::UnknownPredicateException do
+      store.find [:p1, nil]
+    end
+    store.registerPredicate(:p1, 2)
+    assert_equal Set.new([]), store.find([:p1, nil])
+    assert_raise OMF::Rete::Store::UnknownPredicateException do
+      store.find [:p2, nil]
+    end
+  end
+
+  def test_subscribe_across_multiple_predicates
+
+    plan = [[:p1, :x?, :y?], [:p2, :y?]]
+    tuples = [
+      [:p1, 3, 4], [:p1, 4, 5], [:p1, 5, 6],
+      [:p2, 4], [:p2, 6]
+    ]
+    store = create_store()
+    store.registerPredicate(:p1, 3)
+    store.registerPredicate(:p2, 2)
+    tuples.each {|t| store.addTuple t }
+
+    resT = Set.new
+    result = store.subscribe(:test, plan) do |t|
+      resT << t.to_a
+    end
+
+    assert_equal Set.new([[3,4], [5,6]]), resT
+  end
+
+end
+
+
+

data/tests/test_readme.rb

@@ -0,0 +1,66 @@
+require 'omf_rete/store'
+
+#include OMF::Rete
+
+
+#
+# Test the eamples in teh README file
+#
+class TestReadme < Test::Unit::TestCase
+  attr_reader :eng
+
+  def setup
+    @eng = OMF::Rete.create_engine(tuple_length: 3)
+
+    @res = []
+  end
+
+  def puts(msg)
+    @res << msg
+  end
+
+  def assert_puts(expected)
+    assert_equal expected, @res
+  end
+
+  def test_example1
+    eng = OMF::Rete.create_engine(tuple_length: 3)
+    eng.add_fact('myFridge', 'contains', 'milk')
+  end
+
+  def test_example2
+    eng.add_rule(:report_problem, [
+      ['myFridge', 'status', 'broken']
+    ]) do |m|
+      puts "My fridge is broken"
+    end
+    eng.add_fact('myFridge', 'status', 'ok')
+    eng.add_fact('myFridge', 'status', 'broken')
+
+    assert_puts ["My fridge is broken"]
+  end
+
+  def test_example3
+    eng.add_fact('myFridge', 'contains', 'milk')
+    eng.subscribe(:save_milk, [
+      [:fridge?, 'status', 'broken'],
+      [:fridge?, 'contains', 'milk'],
+    ]) do |m|
+      puts "Save the milk from #{m.fridge?}"
+    end
+    eng.add_fact('myFridge', 'status', 'broken')
+
+    assert_puts ["Save the milk from myFridge"]
+  end
+
+  def test_example4
+    eng.subscribe(:something_broken, [
+      [nil, 'status', 'broken']
+    ]) do |m|
+      puts "Something is broken"
+    end
+    eng.add_fact('myFridge', 'status', 'broken')
+
+    assert_puts ["Something is broken"]
+  end
+end

data/tests/test_store.rb

@@ -34,12 +34,21 @@ class TestStore < Test::Unit::TestCase
     r = store.find [t1[0], nil, t1[2]]
     assert_equal r, Set.new([t1])
     
+    r = store.find [t1[0], :_, t1[2]]
+    assert_equal r, Set.new([t1])
+
     r = store.find [nil, nil, nil]
     assert_equal r, Set.new([t1, t2])
+
+    r = store.find [:_, :_, :_]
+    assert_equal r, Set.new([t1, t2])
     
     r = store.find [:b, nil, nil]
     assert_equal r, Set.new()
 
+    r = store.find [:b, :_, :_]
+    assert_equal r, Set.new()
+
   end
 
   def test_find_tuple2
@@ -134,6 +143,48 @@ class TestStore < Test::Unit::TestCase
     assert_equal [t1, t2], ts.tuples
   end
 
+  def test_tset_remove
+    t1 = [:a, :b, :c]
+
+    store = Store.create(3)
+
+    ts = MockTSet.new
+    store.registerTSet(ts, t1)
+
+    store.addTuple t1
+    store.removeTuple t1 
+    assert_equal [], ts.tuples
+  end
+  
+  def test_tset_remove_multiple_nil
+    t1 = [:a, :b, :c]
+
+    store = Store.create(3)
+
+    ts = MockTSet.new
+    store.registerTSet(ts, [nil, t1[1], nil])
+    store.addTuple t1 
+
+    t2 = [:d, :b, :f]
+    store.addTuple t2 
+
+    store.removeTuple t1
+    assert_equal [t2], ts.tuples
+    
+    r = store.find t1
+    assert_equal r, Set.new()
+    r = store.find [:a, nil, nil]
+    assert_equal r, Set.new()
+    
+    t3 = [:g, :h, :j]
+    store.addTuple t3
+    assert_equal [t2], ts.tuples
+    
+    store.removeTuple t2
+    assert_equal [], ts.tuples
+    
+  end
+  
 
 
 
@@ -149,6 +200,11 @@ class MockTSet
     (@tuples ||= []) << t
   end
   
+  def removeTuple(t)
+    @tuples.delete t
+  end
+
+  
   def reset()
     @tuples = nil
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omf_rete
 version: !ruby/object:Gem::Version
-  version: '0.5'
+  version: 0.6.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-13 00:00:00.000000000 Z
-dependencies: []
+date: 2013-12-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: omf_base
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Tuple store with query and filter functionality.
 email:
 - omf-user@lists.nicta.com.au
@@ -36,7 +52,11 @@ files:
 - lib/omf_rete/store/alpha/alpha_element.rb
 - lib/omf_rete/store/alpha/alpha_inner_element.rb
 - lib/omf_rete/store/alpha/alpha_leaf_element.rb
-- lib/omf_rete/store/alpha/alpha_store.rb
+- lib/omf_rete/store/alpha_store.rb
+- lib/omf_rete/store/named_alpha_store.rb
+- lib/omf_rete/store/object_store.rb
+- lib/omf_rete/store/predicate_store.rb
+- lib/omf_rete/tuple.rb
 - lib/omf_rete/tuple_stream.rb
 - lib/omf_rete/version.rb
 - omf_rete.gemspec
@@ -45,7 +65,11 @@ files:
 - tests/test_filter.rb
 - tests/test_indexed_tuple_set.rb
 - tests/test_join_op.rb
+- tests/test_named_store.rb
+- tests/test_object_store.rb
 - tests/test_planner.rb
+- tests/test_predicate_store.rb
+- tests/test_readme.rb
 - tests/test_store.rb
 homepage: https://www.mytestbed.net
 licenses: []
@@ -67,8 +91,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: omf_rete
-rubygems_version: 1.8.24
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: A Rete implementation.
 test_files: []
+has_rdoc: