omf_rete 0.5

data/tests/test_planner.rb

@@ -0,0 +1,232 @@
+require 'omf_rete/store'
+require 'omf_rete/indexed_tuple_set'
+require 'omf_rete/join_op'
+require 'omf_rete/planner/plan_builder'
+require 'stringio'
+
+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
+    
+    resT = []
+    result = store.subscribe(:test, plan, outPattern) do |t|
+      resT << t
+    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)
+    end
+    result
+  end
+
+  def test_build_simple_plan
+    plan = [[:x?, :b, :c]]
+    exp = %{\
+out: [x?]
+  processing
+}
+    inT = [[:a, :b, :c], [:d, :b, :e]]
+    resT = [[:a]]
+    _test_plan plan, 3, exp, inT, resT
+  end
+  
+  def test_build_simple_plan_loaded
+    plan = [[:x?, :b, :c]]
+    exp = %{\
+out: [x?]
+  processing
+}
+    inT = [[:a, :b, :c], [:d, :b, :e]]
+    resT = [[:a]]
+    _test_plan plan, 3, exp, inT, resT
+  end
+
+  
+  def test_project
+    plan = [[:x?, :b, :y?]]
+    exp = %{\
+out: [y?]
+  processing
+}
+    inT = [[:a, :b, :c], [:d, :b, :e]]
+    resT = [[:c], [:e]]
+    _test_plan plan, 3, exp, inT, resT, [:y?]
+  end
+  
+  def test_simple_project
+    plan = [[:x?, :b, :y?]]
+    exp = %{\
+out: [y?]
+  processing
+}
+    inT = [[:a, :b, :c], [:d, :b, :e]]
+    resT = [[:c], [:e]]
+    _test_plan plan, 3, exp, inT, resT, [:y?]
+  end
+  
+  def test_simple_project2
+    plan = [[:x?, :b, :y?]]
+    exp = %{\
+out: [x?]
+  processing
+}
+    inT = [[:a, :b, :c], [:d, :b, :e]]
+    resT = [[:a], [:d]]
+    _test_plan plan, 3, exp, inT, resT, [:x?]
+  end
+  
+  def test_simple_project3
+    plan = [[:x?, :b, :y?]]
+    exp = %{\
+out: [y?, x?]
+  processing
+}
+    inT = [[:a, :b, :c], [:d, :b, :e]]
+    resT = [[:c, :a], [:e, :d]]
+    _test_plan plan, 3, exp, inT, resT, [:y?, :x?]
+  end
+
+  def test_simple
+    plan = [[:x?, :b, :c], [:d, :e, :f]]
+    exp = %{\
+out: [x?]
+  processing
+}
+    inT = [[:a, :b, :c], [:d, :b, :e]]
+    resT = [[:a]]
+    _test_plan plan, 3, exp, inT, resT
+  end
+  
+  def test_build_single_join
+    plan = [[:x?, :b, :c], [:x?, :b, :d]]    
+    exp = %{\
+out: [x?]
+  join: [x?] => [x?]
+    ts: [x?, b, c]  (index: [x?])
+    ts: [x?, b, d]  (index: [x?])
+}
+    inT = [[:a, :b, :c], [:e, :b, :d], [:a, :b, :d]]
+    resT = [[:a]]
+    _test_plan plan, 3, exp, inT, resT
+  end
+  
+  def test_build_single_join_with_project
+    plan = [[:x?, :b, :y?], [:x?, :y?, :d]]    
+    exp = %{\
+out: [y?]
+  join: [x?, y?] => [y?]
+    ts: [x?, b, y?]  (index: [x?, y?])
+    ts: [x?, y?, d]  (index: [x?, y?])
+}
+    inT = [[:a, :b, :c], [:e, :b, :d], [:a, :c, :d]]
+    resT = [[:c]]
+    _test_plan plan, 3, exp, inT, resT, [:y?]
+  end
+
+  def test_build_single_join_with_project2
+    plan = [[:x?, :b, :y?], [:x?, :y?, :d]]    
+    exp = %{\
+out: [y?, x?]
+  join: [x?, y?] => [x?, y?]
+    ts: [x?, b, y?]  (index: [x?, y?])
+    ts: [x?, y?, d]  (index: [x?, y?])
+}
+    inT = [[:a, :b, :c], [:e, :b, :d], [:a, :c, :d]]
+    resT = [[:c, :a]]
+    _test_plan plan, 3, exp, inT, resT, [:y?, :x?]
+  end
+
+
+  def test_build_two_joins
+    plan = [[:x?, :b, :c], 
+            [:y?, :d, nil],
+            [:x?, :e, :y?]]    
+    exp = %{\
+out: [x?, y?]
+  join: [y?] => [x?, y?]
+    ts: [y?, d, *]  (index: [y?])
+    ts: [x?, y?]  (index: [y?])
+      join: [x?] => [x?, y?]
+        ts: [x?, b, c]  (index: [x?])
+        ts: [x?, e, y?]  (index: [x?])
+}
+    inT = [[:x, :b, :c], [:y, :d, :f], [:x, :e, :y]]
+    resT = [[:x, :y]]
+    _test_plan plan, 3, exp, inT, resT
+
+  end
+
+  def test_build_three_joins
+    plan = [[:x?, :a, :b], 
+            [:y?, :c, :d],
+            [:x?, :e, :z?],
+            [:z?, :f, :y?]]    
+    exp = %{\
+out: [x?, y?, z?]
+  join: [z?] => [x?, y?, z?]
+    ts: [x?, z?]  (index: [z?])
+      join: [x?] => [x?, z?]
+        ts: [x?, a, b]  (index: [x?])
+        ts: [x?, e, z?]  (index: [x?])
+    ts: [y?, z?]  (index: [z?])
+      join: [y?] => [y?, z?]
+        ts: [y?, c, d]  (index: [y?])
+        ts: [z?, f, y?]  (index: [y?])
+}
+    inT = [[:x, :a, :b], [:y, :c, :d], [:x, :e, :z], [:z, :f, :y]]
+    resT = [[:x, :y, :z]]
+    _test_plan plan, 3, exp, inT, resT
+  end
+  
+
+  def test_siblings
+    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
+    end
+    assert_equal(Set.new, resT)
+    
+    subscription = [
+      [:x?, :hasParent, :p?], 
+      [:y?, :hasParent, :p?],
+      OMF::Rete.differ(:x?, :y?) 
+    ]
+    store.query(subscription, [:x?, :y?]) do |x, y|
+      store.addTuple([x, :sibling_of, y])
+    end
+
+    assert_equal(Set.new([[:b, :a], [:a, :b]]), resT)
+    
+  end
+end

data/tests/test_store.rb

@@ -0,0 +1,157 @@
+require 'omf_rete/store'
+
+include OMF::Rete
+
+class TestStore < Test::Unit::TestCase
+  def test_create_store
+    store = Store.create(3)
+  end
+  
+  def test_add_tuple
+    store = Store.create(3)
+    store.addTuple [:a, :b, :c]
+  end
+  
+  def test_add_tuple2
+    store = Store.create(3)
+    store.add :a, :b, :c
+  end
+
+  def test_find
+    t1 = [:a, :b, :c]
+    t2 = [t1[0], t1[1], :d] 
+    store = Store.create(3)
+    
+    store.addTuple t1 
+    store.addTuple t2
+    
+    r = store.find t1
+    assert_equal r, Set.new([t1])
+    
+    r = store.find [t1[0], t1[1], nil]
+    assert_equal r, Set.new([t1, t2])
+
+    r = store.find [t1[0], nil, t1[2]]
+    assert_equal r, Set.new([t1])
+    
+    r = store.find [nil, nil, nil]
+    assert_equal r, Set.new([t1, t2])
+    
+    r = store.find [:b, nil, nil]
+    assert_equal r, Set.new()
+
+  end
+
+  def test_find_tuple2
+    store = Store.create(3)
+    store.add :a, :b, :c
+    
+    t1 = [:a, :b, :c]
+    r = store.find t1
+    assert_equal r, Set.new([t1])
+  end
+
+  def test_tset_init
+    t1 = [:a, :b, :c]
+    store = Store.create(3)
+    store.addTuple t1 
+
+    ts = MockTSet.new
+    store.registerTSet(ts, t1)
+    assert_equal ts.tuples, [t1]
+  end
+
+  def test_tset_add_full
+    t1 = [:a, :b, :c]
+
+    store = Store.create(3)
+
+    ts = MockTSet.new
+    store.registerTSet(ts, t1)
+    assert_equal nil, ts.tuples
+
+    store.addTuple t1 
+    assert_equal [t1], ts.tuples
+  end
+
+  def test_tset_add_last_nil
+    t1 = [:a, :b, :c]
+
+    store = Store.create(3)
+
+    ts = MockTSet.new
+    store.registerTSet(ts, [t1[0], t1[1], nil])
+    assert_equal nil, ts.tuples
+
+    store.addTuple t1 
+    assert_equal [t1], ts.tuples
+  end
+
+  def test_tset_add_second_nil
+    t1 = [:a, :b, :c]
+
+    store = Store.create(3)
+
+    ts = MockTSet.new
+    store.registerTSet(ts, [t1[0], nil, t1[2]])
+    assert_equal nil, ts.tuples
+
+    store.addTuple t1 
+    assert_equal [t1], ts.tuples
+  end
+  
+  def test_tset_add_first_nil
+    t1 = [:a, :b, :c]
+
+    store = Store.create(3)
+
+    ts = MockTSet.new
+    store.registerTSet(ts, [nil, t1[1], t1[2]])
+    assert_equal nil, ts.tuples
+
+    store.addTuple t1 
+    assert_equal [t1], ts.tuples
+  end
+  
+  def test_tset_add_multiple_nil
+    t1 = [:a, :b, :c]
+
+    store = Store.create(3)
+
+    ts = MockTSet.new
+    store.registerTSet(ts, [nil, t1[1], nil])
+    assert_equal nil, ts.tuples
+
+    store.addTuple t1 
+    assert_equal [t1], ts.tuples
+    
+    t2 = [:d, :b, :f]
+    store.addTuple t2 
+    assert_equal [t1, t2], ts.tuples
+
+    t3 = [:g, :h, :j]
+    store.addTuple t3
+    assert_equal [t1, t2], ts.tuples
+  end
+
+
+
+
+
+#          assert_instance_of OEDLMissingArgumentException, ex
+#          assert_equal :name, ex.argName
+end
+
+class MockTSet
+  attr_reader :tuples
+  
+  def addTuple(t)
+    (@tuples ||= []) << t
+  end
+  
+  def reset()
+    @tuples = nil
+  end
+end # MockTSet
+
+

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: omf_rete
+version: !ruby/object:Gem::Version
+  version: '0.5'
+  prerelease: 
+platform: ruby
+authors:
+- NICTA
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-13 00:00:00.000000000 Z
+dependencies: []
+description: Tuple store with query and filter functionality.
+email:
+- omf-user@lists.nicta.com.au
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- README.md
+- Rakefile
+- lib/omf_rete.rb
+- lib/omf_rete/abstract_tuple_set.rb
+- lib/omf_rete/indexed_tuple_set.rb
+- lib/omf_rete/join_op.rb
+- lib/omf_rete/planner/abstract_plan.rb
+- lib/omf_rete/planner/filter_plan.rb
+- lib/omf_rete/planner/join_plan.rb
+- lib/omf_rete/planner/plan_builder.rb
+- lib/omf_rete/planner/plan_level_builder.rb
+- lib/omf_rete/planner/plan_set.rb
+- lib/omf_rete/planner/source_plan.rb
+- lib/omf_rete/store.rb
+- 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/tuple_stream.rb
+- lib/omf_rete/version.rb
+- omf_rete.gemspec
+- tests/test.rb
+- tests/test_backtracking.rb
+- tests/test_filter.rb
+- tests/test_indexed_tuple_set.rb
+- tests/test_join_op.rb
+- tests/test_planner.rb
+- tests/test_store.rb
+homepage: https://www.mytestbed.net
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: omf_rete
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A Rete implementation.
+test_files: []