omf_rete 0.5

data/lib/omf_rete/tuple_stream.rb

@@ -0,0 +1,241 @@
+
+
+module OMF::Rete
+  #
+  # 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 
+      @source = source
+    end
+
+    def index_for_binding(bname)
+      @description.find_index do |el|
+        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)
+      if @source
+        @source.describe(out, offset + incr, incr, sep)
+      end
+    end
+  end
+
+
+  # A processing tuple stream calls the associated processing block
+  # for every incoming tuple and forwards what is being returned by
+  # this block to the +receiver+. The return value of the block
+  # is assumed by a tuple as well. If the return value is nil,
+  # nothing is forwarded and the incoming tuple is essentially dropped.
+  #
+  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
+      @result_size = out_description.size
+      if in_description
+        self.inDescription = in_description
+      end
+      @receiver = receiver
+      @block = block
+    end
+    
+    def on_add(&block)
+      @block = block
+    end
+    
+    def addTuple(tuple)
+      if @result_map
+        rtuple = @result_map.collect do |i| tuple[i] end
+      else
+        rtuple = tuple
+      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    
+    
+    def source=(source)
+      super
+      if source
+        self.inDescription = source.description
+      end
+    end
+
+    def inDescription=(in_description)
+      if in_description
+        @result_map = @project_pattern.collect do |name|
+          index = in_description.find_index do |n2| name == n2 end
+          if index.nil?
+            raise "Unknown selector '#{name}'"
+          end
+          index
+        end
+      end
+    end
+    
+    private
+    
+    def process_result(result, original_tuple)
+      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)
+      end
+    end
+    
+    def _describe(out, sep )
+      out.write("processing#{sep}")
+    end
+
+  end # ProcessingTupleStream
+
+  # A result tuple stream calls the associated processing block
+  # 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 
+  # +ProcessingTupleStream+ as well.
+  #
+  class ResultTupleStream < AbstractTupleStream
+
+    def initialize(description, supress_duplicates = true, &block)
+      super description
+      @block = block
+      if supress_duplicates
+        @results = Set.new
+      end
+    end
+    
+    def source=(source)
+      @source = source
+      if @source.description != @description
+        @result_map = @description.collect do |name|
+          index = @source.description.find_index do |n2| name == n2 end
+          if index.nil?
+            raise "Unknown selector '#{name}'"
+          end
+          index
+        end
+      end
+    end
+    
+    def addTuple(tuple)
+      if @result_map
+        rtuple = @result_map.collect do |i| tuple[i] end
+      else
+        rtuple = tuple
+      end
+      if @results
+        if @results.add?(rtuple)
+          @block.call(rtuple)
+        end
+      else
+        @block.call(rtuple)          
+      end
+    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 
+        # 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
+          up_tuple = @expand_map.collect do |i| i nil? ? nil : tuple[i] end
+        else
+          up_tuple = tuple
+        end
+        @source.check_for_tuple(up_tuple)
+      end
+    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 
+  # the block returns true, otherwise it drops the tuple.
+  #
+  class FilterTupleStream < ProcessingTupleStream
+
+    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
+    # able to produce the tuple in question.
+    #
+    # TODO: This currently doesn't work for tuples with wild cards.
+    #
+    def check_for_tuple(tuple)
+      if @sourcce 
+        # should check if +tuple+ has the same size as description
+        if @result_map
+          rtuple = @result_map.collect do |i| tuple[i] end
+        else
+          rtuple = tuple
+        end
+        if @block.call(*rtuple)
+          @source.check_for_tuple(tuple)
+        end
+      end
+    end
+    
+    private
+    
+    def process_result(result, original_tuple)
+      if (result)
+        @receiver.addTuple(original_tuple)
+      end
+    end
+    
+    
+    def _describe(out, sep )
+      out.write("filtering#{sep}")
+    end
+
+  end # class
+end # module
+

data/lib/omf_rete/version.rb

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

data/lib/omf_rete.rb

@@ -0,0 +1,35 @@
+
+
+
+module OMF
+  module Rete
+    
+    # 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
+    # bindings for the block, while the second one describes the tuple returned
+    # by the block.
+    #
+    def self.filter(*projectPattern, &block)
+      require 'omf_rete/planner/filter_plan'
+      if projectPattern[0].kind_of? Array
+        if projectPattern.size != 2
+          raise "Wrong arguments for 'filter'. See documentation."
+        end
+        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
+      end
+    end
+
+  end # Filter
+end # Moana

data/omf_rete.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "omf_rete/version"
+
+Gem::Specification.new do |s|
+  s.name        = "omf_rete"
+#  s.version     = OmfWeb::VERSION
+  s.version     = OMF::Rete::VERSION
+  s.authors     = ["NICTA"]
+  s.email       = ["omf-user@lists.nicta.com.au"]
+  s.homepage    = "https://www.mytestbed.net"
+  s.summary     = %q{A Rete implementation.}
+  s.description = %q{Tuple store with query and filter functionality.}
+
+  s.rubyforge_project = "omf_rete"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- {bin,sbin}/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+#  s.add_development_dependency "minitest", "~> 2.11.3"
+end

data/tests/test.rb

@@ -0,0 +1,8 @@
+#$:.unshift((File.dirname(__FILE__)) + '../../lib').unshift(File.dirname(__FILE__) + '..')
+
+require 'test/unit'
+
+Dir.glob("#{File.dirname(__FILE__)}/test_*.rb").each do |fn|
+  load fn
+end
+

data/tests/test_backtracking.rb

@@ -0,0 +1,42 @@
+
+class TestBacktracking < Test::Unit::TestCase
+  
+  def _test_plan(plan, storeSize, inTuples = nil, outTuples = nil, outPattern = nil, &requestProc)
+    store = Store.create(storeSize)
+    store.on_query &requestProc # proc to call if store gets a request for a tuple which doesn't exist
+    pb = PlanBuilder.new(plan, store, :backtracking => true)
+    pb.build
+
+#    pb.describe
+
+    resT = []
+    result = pb.materialize(outPattern) do |t|
+      resT << t
+    end
+      
+    if (inTuples)
+      inTuples.each do |t|
+        store.addTuple(t)
+      end
+      assert_equal(outTuples, resT)
+    end
+    result
+  end
+  
+  def x_test_request_one
+    plan = [
+      [:user?, :do, :action?], 
+      [:pi, :endorses, :user?]
+    ]
+    inT = [[:u1, :do, :start]]
+    resT = inT
+    _test_plan plan, 3, inT, resT do |*t|
+      puts ">>>>>>>>>>>"
+    end
+    
+  end  
+  
+  def test_dummy
+    assert_equal(1, 1)
+  end
+end # TestBacktracking

data/tests/test_filter.rb

@@ -0,0 +1,77 @@
+require 'omf_rete'
+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 TestFilter < Test::Unit::TestCase
+  
+
+  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
+      
+    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_theshold_test
+    plan = [
+      [:x?], 
+      OMF::Rete.filter(:x?) do |x|
+        x > 2
+      end
+    ]
+    exp = %{\
+out: [x?]
+  filtering
+    processing
+}
+    inT = [[1], [2], [3], [4]]
+    resT = [[3], [4]]
+    _test_plan plan, 1, exp, inT, resT
+  end
+  
+  def test_theshold_test2
+    plan = [
+      [:x?, :y?], 
+      OMF::Rete::filter(:x?) do |x|
+        x > 2
+      end,
+      OMF::Rete.filter(:y?) do |y|
+        y > 13
+      end
+    ]
+    exp = %{\
+out: [x?, y?]
+  filtering
+    filtering
+      processing
+}
+    inT = [[1, 11], [2, 12], [3, 13], [4, 14]]
+    resT = [[4, 14]]
+    _test_plan plan, 2, exp, inT, resT
+  end
+end

data/tests/test_indexed_tuple_set.rb

@@ -0,0 +1,58 @@
+require 'omf_rete/indexed_tuple_set'
+
+include OMF::Rete
+
+class TestIndexedTupleSet < Test::Unit::TestCase
+  def test_create_tset
+    IndexedTupleSet.new([:x?], [:x?])
+    IndexedTupleSet.new([:x?, nil, :y?], [:x?])    
+  end
+  
+  def test_add_tuple
+    t = [:a, :b, :c]
+    ts = IndexedTupleSet.new([:x?, nil, nil], [:x?])
+    ts.addTuple(t)
+    assert_equal [t], ts.to_a
+  end
+  
+  def test_index0
+    t = [:a, :b, :c]
+    ts = IndexedTupleSet.new([:x?, nil, nil], [:x?])
+    ts.addTuple(t)
+    assert_equal [t], ts[[t[0]]].to_a
+  end
+
+  
+  def test_add_tuple_def_ts2
+    t1 = ['a', 'b', 'c']  # use strings as we need to sort tuple arrays
+    t2 = ['a', 'b', 'd']
+    ts = IndexedTupleSet.new([:x?], [:x?])
+    ts.addTuple(t1)
+    ts.addTuple(t2)    
+    assert_equal [t1, t2].sort, ts.to_a.sort
+  end
+  
+  def test_index_pattern
+    t = [:a, :b, :c]
+    ts = IndexedTupleSet.new([:x?, :y?, :z?], [:y?, :x?])
+    ts.addTuple(t)
+    assert_equal [t], ts[[t[1], t[0]]].to_a
+  end
+
+  def test_add_tuple_each
+    t1 = ['a', 'b', 'c']  # use strings as we need to sort tuple arrays
+    t2 = ['a', 'b', 'd']
+    ts = IndexedTupleSet.new([:x?, :y?, :z?], [:x?])
+    ts.addTuple(t1)
+    a = []
+    ts.on_add do |t|
+      a << t
+    end
+    assert_equal [t1], a
+    ts.addTuple(t2)    
+    assert_equal [t1, t2], a
+  end
+     
+
+
+end

data/tests/test_join_op.rb

@@ -0,0 +1,50 @@
+require 'omf_rete/join_op'
+
+include OMF::Rete
+
+class TestJoinOP < Test::Unit::TestCase
+  def test_create_joinop
+    l = IndexedTupleSet.new([:x?], [:x?])
+    r = IndexedTupleSet.new([:x?], [:x?])
+    out = IndexedTupleSet.new([:x?], [:x?])
+    JoinOP.new(l, r, out)
+  end
+  
+  # [:a :x?], [?x :c]
+  #
+  def test_join1
+    t1 = ['a', 'b']
+    t2 = ['b', 'd']
+    l = OMF::Rete::IndexedTupleSet.new([:a?, :x?], [:x?])
+    r = OMF::Rete::IndexedTupleSet.new([:x?, :b?], [:x?])
+    out = IndexedTupleSet.new([:a?, :b?], [:a?])
+    JoinOP.new(l, r, out)
+    l.addTuple(t1)
+    r.addTuple(t2)
+    assert_equal [[t1[0], t2[1]]], out.to_a
+  end
+  
+  def test_three_result_set
+    t1 = ['y', 'z', 'b', 'x']
+    t2 = ['c', 'd', 'x', 'b']
+    l = OMF::Rete::IndexedTupleSet.new([:y?, :z?, :b, :x?], [:x?])
+    r = OMF::Rete::IndexedTupleSet.new([:c, :d, :x?, :b], [:x?])
+    out = IndexedTupleSet.new([:x?, :y?, :z?], [:x?])
+    JoinOP.new(l, r, out)
+    l.addTuple(t1)
+    r.addTuple(t2)
+    assert_equal [['x', 'y', 'z']], out.to_a
+  end
+  
+  def test_join2
+    t1 = ['y', 'z', 'b', 'x']
+    t2 = ['c', 'd', 'x', 'y']
+    l = OMF::Rete::IndexedTupleSet.new([:y?, :z?, :b, :x?], [:x?, :y?])
+    r = OMF::Rete::IndexedTupleSet.new([:c, :d, :x?, :y?], [:x?, :y?])
+    out = IndexedTupleSet.new([:x?, :y?, :z?], [:x?])
+    JoinOP.new(l, r, out)
+    l.addTuple(t1)
+    r.addTuple(t2)
+    assert_equal [['x', 'y', 'z']], out.to_a
+  end
+end