oflow 0.3.0

data/lib/oflow/version.rb

@@ -0,0 +1,5 @@
+
+module OFlow
+  # Current version of the module. 
+  VERSION = '0.3.0'
+end

data/lib/oflow.rb

@@ -0,0 +1,23 @@
+
+module OFlow
+end
+
+require 'oflow/errors'
+require 'oflow/stamp'
+require 'oflow/hasname'
+require 'oflow/hastasks'
+require 'oflow/haslinks'
+require 'oflow/haserrorhandler'
+require 'oflow/haslog'
+require 'oflow/pattern'
+require 'oflow/tracker'
+require 'oflow/box'
+require 'oflow/actor'
+require 'oflow/task'
+require 'oflow/link'
+require 'oflow/flow'
+
+require 'oflow/actors'
+
+require 'oflow/env'
+require 'oflow/inspector'

data/test/actors/log_test.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+[ File.dirname(__FILE__),
+  File.join(File.dirname(__FILE__), "../../lib"),
+  File.join(File.dirname(__FILE__), "..")
+].each { |path| $: << path unless $:.include?(path) }
+
+require 'test/unit'
+require 'stringio'
+require 'oflow'
+
+class LogTest < ::Test::Unit::TestCase
+
+  def test_log
+    stream = StringIO.new()
+    log = ::OFlow::Task.new(nil, 'log', ::OFlow::Actors::Log,
+                            :stream => stream,
+                            :severity => Logger::INFO,
+                            :formatter => proc { |sev, time, prog, msg| "#{sev}: #{msg}\n" })
+
+    log.receive(:fatal, ::OFlow::Box.new(['dead msg', 'Dead']))
+    log.receive(:error, ::OFlow::Box.new(['oops msg', 'Oops']))
+    log.receive(:warn, ::OFlow::Box.new(['duck msg', 'Duck']))
+    log.receive(:info, ::OFlow::Box.new(['something msg', 'Something']))
+    log.receive(:debug, ::OFlow::Box.new(['bugs msg', 'Bugs']))
+
+    log.flush()
+    assert_equal(%{FATAL: dead msg
+ERROR: oops msg
+WARN: duck msg
+INFO: something msg
+}, stream.string)
+
+    log.shutdown()
+  end
+
+  def test_log_filename
+    filename = 'filename_test.log'
+    %x{rm -f #{filename}}
+
+    log = ::OFlow::Task.new(nil, 'log', ::OFlow::Actors::Log,
+                            :filename => filename,
+                            :severity => Logger::INFO,
+                            :formatter => proc { |sev, time, prog, msg| "#{sev}: #{msg}\n" })
+
+    log.receive(:info, ::OFlow::Box.new(['first entry', 'One']))
+    log.flush()
+
+    output = File.read(filename).split("\n")[1..-1]
+    assert_equal(['INFO: first entry'], output)
+    %x{rm #{filename}}
+
+    log.shutdown()
+  end
+
+end # LogTest

data/test/actors/timer_test.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+[ File.dirname(__FILE__),
+  File.join(File.dirname(__FILE__), "../../lib"),
+  File.join(File.dirname(__FILE__), "..")
+].each { |path| $: << path unless $:.include?(path) }
+
+require 'test/unit'
+require 'oflow'
+
+require 'collector'
+
+class TimerTest < ::Test::Unit::TestCase
+
+  def test_timer_repeat
+    period = 0.1
+    timer = nil
+    collector = nil
+    ::OFlow::Env.flow('one-time') { |f|
+      f.task('once', ::OFlow::Actors::Timer, repeat: 4, period: period) { |t|
+        timer = t
+        t.link(:ping, :collector, :tick)
+      }
+      f.task(:collector, Collector) { |t|
+        collector = t.actor
+      }
+    }
+    ::OFlow::Env.flush()
+    prev = nil
+    ticks = collector.collection.map do |t|
+      tf = t[2].to_f
+      if prev.nil?
+        tick = [t[1], tf, 0.0]
+      else
+        tick = [t[1], tf, tf - prev]
+      end
+      prev = tf
+      tick
+    end
+    
+    ticks.size.times do |i|
+      tick = ticks[i]
+      assert_equal(i + 1, tick[0])
+      next if 0 == i
+      dif = tick[2] - period
+      limit = period / 10 # 10% accuracy
+      assert(-limit < dif && dif < limit, "Verify timer fires are within 10% of expected. (dif: #{dif}, limit: #{limit})")
+    end
+
+    ::OFlow::Env.clear()
+  end
+
+  # TBD more tests on start, stop, combinations of options, and error conditions
+
+end # TimerTest

data/test/actorwrap_test.rb

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+[ File.dirname(__FILE__),
+  File.join(File.dirname(__FILE__), "../lib")
+].each { |path| $: << path unless $:.include?(path) }
+
+require 'test/unit'
+require 'oflow'
+require 'oflow/test'
+
+class Nonsense < ::OFlow::Actor
+  def initialize(task, options)
+    super
+    @cnt = 0
+  end
+
+  def perform(op, box)
+    @cnt += 1
+    task.ship(:start, ::OFlow::Box.new(@cnt))
+    task.ship(op, box)
+    task.info("finished #{@cnt}")
+  end
+
+end # Nonsense
+
+class ActorWrapTest < ::Test::Unit::TestCase
+
+  def test_actorwrap
+    wrap = ::OFlow::Test::ActorWrap.new('wrapper', Nonsense)
+
+    wrap.receive(:first, ::OFlow::Box.new('word'))
+    history = wrap.history.map { |action| action.to_s }
+    assert_equal(['start: 1', 'first: word', 'log: [:info, "finished 1", ":test:wrapper"]'], history)
+
+    wrap.receive(:second, ::OFlow::Box.new('This is a sentence.'))
+    history = wrap.history.map { |action| action.to_s }
+    assert_equal(['start: 1', 'first: word', 'log: [:info, "finished 1", ":test:wrapper"]',
+                 'start: 2', 'second: This is a sentence.', 'log: [:info, "finished 2", ":test:wrapper"]'], history)
+
+    wrap.reset()
+    assert_equal([], wrap.history)
+    wrap.receive(:third, ::OFlow::Box.new('word'))
+    history = wrap.history.map { |action| action.to_s }
+    assert_equal(['start: 3', 'third: word', 'log: [:info, "finished 3", ":test:wrapper"]'], history)
+  end
+
+end # ActorWrapTest

data/test/all_tests.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+[ File.dirname(__FILE__),
+  File.join(File.dirname(__FILE__), "../lib")
+].each { |path| $: << path unless $:.include?(path) }
+
+
+require 'test/unit'
+
+require 'box_test'
+require 'task_test'
+require 'tracker_test'
+require 'actorwrap_test'
+
+require 'flow_basic_test'
+require 'flow_rescue_test'
+require 'flow_log_test'
+require 'flow_cfg_error_test'
+require 'flow_rescue_test'
+require 'flow_nest_test'
+require 'flow_tracker_test'
+
+# Actor tests
+require 'actors/log_test'
+require 'actors/timer_test'
+

data/test/box_test.rb

@@ -0,0 +1,127 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+# Ubuntu does not accept arguments to ruby when called using env. To get warnings to show up the -w options is
+# required. That can be set in the RUBYOPT environment variable.
+# export RUBYOPT=-w
+
+$VERBOSE = true
+
+$: << File.join(File.dirname(__FILE__), "../lib")
+
+require 'test/unit'
+require 'oflow'
+
+class Access
+  attr_accessor :x, :y
+  def initialize(x, y)
+    @x = x
+    @y = y
+  end
+end # Access
+
+class BoxTest < ::Test::Unit::TestCase
+
+  def test_box_new
+    data = { a: [1, 'first'], b: true }
+    t = ::OFlow::Tracker.create('test')
+    box = ::OFlow::Box.new(data, t)
+
+    assert_equal(data, box.contents, 'data should be the same as what was passed in')
+    assert_equal(t, box.tracker, 'tracker should be the same as what was passed in')
+  end
+
+  def test_box_freeze
+    data = { a: [1, 'first'], b: true }
+    t = ::OFlow::Tracker.create('test')
+    box = ::OFlow::Box.new(data, t).freeze()
+
+    assert_equal(true, box.frozen?, 'box should be frozen')
+    assert_equal(true, box.contents.frozen?, 'contents should be frozen')
+    assert_equal(true, box.contents[:a].frozen?, 'members of contents should be frozen')
+    assert_equal(true, box.contents[:a][1].frozen?, 'members of contentes should be frozen all the way down')
+    assert_equal(true, box.tracker.frozen?, 'tracker should be frozen')
+  end
+
+  def test_box_thaw
+    data = { a: [1, 'first'], b: true }
+    t = ::OFlow::Tracker.create('test')
+    box = ::OFlow::Box.new(data, t).freeze()
+    # make sure it is frozen first.
+    assert_equal(true, box.frozen?, 'box should be frozen')
+    box = box.thaw()
+
+    assert_equal(false, box.frozen?, 'box should not be frozen')
+    assert_equal(false, box.contents.frozen?, 'contents not should be frozen')
+    assert_equal(false, box.contents[:a].frozen?, 'members of contents should not be frozen')
+    assert_equal(false, box.contents[:a][1].frozen?, 'members of contentes should not be frozen all the way down')
+    assert_equal(true, box.tracker.frozen?, 'tracker should still be frozen')
+  end
+
+  def test_box_receive
+    data = { a: [1, 'first'], b: true }
+    t = ::OFlow::Tracker.create('test')
+    box = ::OFlow::Box.new(data, t).freeze()
+    # make sure it is frozen first.
+    assert_equal(true, box.frozen?, 'box should be frozen')
+
+    rbox = box.receive('here', 'try')
+    assert_equal(false, rbox.frozen?, 'box should not be frozen')
+    assert_equal(true, box.contents.frozen?, 'contents should be frozen')
+    assert_equal(2, rbox.tracker.track.size, 'track should have 2 entries')
+    assert_equal('test-', rbox.tracker.track[0].where, 'check track entry 0')
+    assert_equal('here-try', rbox.tracker.track[1].where, 'check track entry 1')
+  end
+
+  def test_box_get
+    data = { a: [1, 'first'], b: true, 'c' => 'see', d: Access.new([7, 3], :y) }
+    box = ::OFlow::Box.new(data).freeze()
+    # Hash access
+    assert_equal(true, box.get('b'), 'get b')
+    assert_equal('see', box.get('c'), 'get c')
+    assert_equal(nil, box.get('x'), 'get x')
+    # Array access
+    assert_equal(1, box.get('a:0'), 'get a:0')
+    assert_equal('first', box.get('a:1'), 'get a:1')
+    assert_equal(nil, box.get('a:2'), 'get a:2')
+    # nil path
+    assert_equal(data, box.get(nil), 'get nil')
+    assert_equal(data, box.get(''), 'get nil')
+    # Object
+    assert_equal([7, 3], box.get('d:x'), 'get d:x')
+    assert_equal(7, box.get('d:x:0'), 'get d:x:0')
+    assert_equal(:y, box.get('d:y'), 'get d:y')
+    assert_equal(nil, box.get('d:z'), 'get d:z')
+    # more bad paths
+    assert_equal(nil, box.get('b:0'), 'get b:0')
+  end
+
+  def test_box_set
+    data = { a: [1, 'first'], b: true, 'c' => 'see', d: Access.new([7, 3], :y) }
+    box = ::OFlow::Box.new(data).freeze()
+
+    b2 = box.set('b', false)
+    assert_equal(false, b2.get('b'), 'get b')
+    assert_equal(true, box.contents[:a].frozen?, 'other contents should be frozen')
+
+    b2 = box.set('a:0', 3)
+    assert_equal(3, b2.get('a:0'), 'get a:0')
+
+    b2 = box.set('a:2', 5)
+    assert_equal(5, b2.get('a:2'), 'get a:2')
+
+    b2 = box.set('c', 'mite')
+    assert_equal('mite', b2.get('c'), 'get c')
+
+    b2 = box.set('e:ha', 'new')
+    assert_equal('new', b2.get('e:ha'), 'get e:ha')
+
+    b2 = box.set('f:1', 'new')
+    assert_equal(Array, b2.get('f').class, 'get f class')
+    assert_equal(nil, b2.get('f:0'), 'get f:0')
+    assert_equal('new', b2.get('f:1'), 'get f:1')
+
+    assert_raise(::OFlow::FrozenError) { box.set('d:x:1', 'three') }
+  end
+
+end # BoxTest

data/test/collector.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+[ File.dirname(__FILE__),
+  File.join(File.dirname(__FILE__), "../lib")
+].each { |path| $: << path unless $:.include?(path) }
+
+require 'oflow'
+
+class Collector < ::OFlow::Actor
+  attr_accessor :collection
+
+  def initialize(task, options)
+    super
+    @collection = []
+  end
+
+  def perform(op, box)
+    @collection << box.contents
+  end
+
+end # Collector
+

data/test/flow_basic_test.rb

@@ -0,0 +1,93 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+[ File.dirname(__FILE__),
+  File.join(File.dirname(__FILE__), "../lib")
+].each { |path| $: << path unless $:.include?(path) }
+
+require 'test/unit'
+require 'oflow'
+
+require 'collector'
+
+class Stutter < ::OFlow::Actor
+  
+  def initialize(task, options)
+    super
+    @collector = nil
+  end
+
+  def perform(op, box)
+    if @collector.nil?
+      @collector = task.ship(:collector, ::OFlow::Box.new([task.full_name, op, box.contents]))
+    else
+      @collector.ship(::OFlow::Box.new([task.full_name, op, box.contents, 'with_link']))
+    end
+    task.ship(op, box)
+  end
+
+end # Stutter
+
+class FlowBasicTest < ::Test::Unit::TestCase
+
+  def test_flow_basic
+    trigger = nil
+    collector = nil
+    ::OFlow::Env.flow('basic', :opt1 => 1) { |f|
+      # collects results
+      f.task(:collector, Collector) { |t|
+        collector = t.actor
+      }
+      # starts off the process
+      trigger = f.task('trigger', Stutter) { |t|
+        t.link(:collector, 'collector', 'trigger')
+        t.link(:once, 'dub', :twice)
+      }
+      # sends to self and then ends with no other task to ship to
+      f.task('dub', Stutter, :opt1 => 7) { |t|
+        t.link(:collector, 'collector', 'dub')
+        t.link(:twice, 'dub', :once)
+        t.link(:once, 'ignore', nil)
+      }
+      f.task(:ignore, ::OFlow::Actors::Ignore)
+    }
+    # see if the flow was constructed correctly
+    assert_equal(%|OFlow::Env {
+  basic (OFlow::Flow) {
+    collector (Collector) {
+    }
+    trigger (Stutter) {
+      collector => collector:trigger
+      once => dub:twice
+    }
+    dub (Stutter) {
+      collector => collector:dub
+      twice => dub:once
+      once => ignore:
+    }
+    ignore (OFlow::Actors::Ignore) {
+    }
+  }
+}|, ::OFlow::Env.describe())
+
+    # run it and check the output
+    trigger.receive(:once, ::OFlow::Box.new(7))
+    ::OFlow::Env.flush()
+    assert_equal([[':basic:trigger', :once, 7],
+                  [':basic:dub', :twice, 7],
+                  [':basic:dub', :once, 7, 'with_link'],
+                 ], collector.collection)
+
+    # run again and make sure all tasks use links
+    collector.collection = []
+    trigger.receive(:once, ::OFlow::Box.new(7))
+    ::OFlow::Env.flush()
+    assert_equal([[':basic:trigger', :once, 7, 'with_link'],
+                  [':basic:dub', :twice, 7, 'with_link'],
+                  [':basic:dub', :once, 7, 'with_link'],
+                 ], collector.collection)
+
+    ::OFlow::Env.clear()
+  end
+
+end # FlowBasicTest

data/test/flow_cfg_error_test.rb

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+[ File.dirname(__FILE__),
+  File.join(File.dirname(__FILE__), "../lib")
+].each { |path| $: << path unless $:.include?(path) }
+
+require 'test/unit'
+require 'oflow'
+
+require 'collector'
+
+class Dummy < ::OFlow::Actor
+  
+  def initialize(task, options)
+    super
+  end
+
+  def perform(op, box)
+    task.ship(op, box)
+  end
+
+end # Dummy
+
+class Miss < ::OFlow::Actor
+  
+  def initialize(task, options)
+    super
+  end
+
+  def perform(op, box)
+    case op
+    when :one
+      task.ship(:one, box)
+    when :two
+      task.ship(:two, box)
+    end
+  end
+
+  def inputs()
+    [ ::OFlow::Actor::Spec.new(:fixnum, Fixnum),
+      ::OFlow::Actor::Spec.new(:float, nil) ]
+  end
+
+  def outputs()
+    [ ::OFlow::Actor::Spec.new(:fixnum, Fixnum),
+      ::OFlow::Actor::Spec.new(:float, Float) ]
+  end
+
+end # Miss
+
+class FlowCfgErrTest < ::Test::Unit::TestCase
+
+  def test_flow_link_unresolved
+    begin
+      ::OFlow::Env.flow('unresolved', :opt1 => 1) { |f|
+        f.task(:one, Dummy) { |t|
+          t.link(:two, :two, nil)
+        }
+        f.task(:three, Dummy) { |t|
+          t.link(:second, :two, nil)
+        }
+      }
+      assert(false, "expected a ValidateError")
+    rescue ::OFlow::ValidateError => ve
+      assert_equal([":unresolved:one: Failed to find task 'two'.",
+                    ":unresolved:three: Failed to find task 'two'."], ve.problems.map { |p| p.to_s })
+    end
+    ::OFlow::Env.clear()
+  end
+
+  def test_flow_link_missing
+    begin
+      ::OFlow::Env.flow('miss-me') { |f|
+        f.task(:sort, Miss) { |t|
+          t.link(:fixnum, :fix, nil)
+        }
+        f.task(:fix, Dummy) { |t|
+          t.link(:repeat, :sort, :float)
+          t.link(:wrong, :sort, :complex)
+        }
+      }
+      assert(false, "expected a ValidateError")
+    rescue ::OFlow::ValidateError => ve
+      assert_equal([":miss-me:sort: Missing link for 'float'.",
+                    ":miss-me:fix: 'complex' not allowed on ':miss-me:sort'."], ve.problems.map { |p| p.to_s })
+    end
+    ::OFlow::Env.clear()
+  end
+
+  # TBD missing links for output spec
+
+
+end # FlowCfgErrTest

data/test/flow_log_test.rb

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+[ File.dirname(__FILE__),
+  File.join(File.dirname(__FILE__), "../lib")
+].each { |path| $: << path unless $:.include?(path) }
+
+require 'test/unit'
+require 'oflow'
+
+require 'collector'
+
+class Noise < ::OFlow::Actor
+  
+  def initialize(task, options)
+    super
+  end
+
+  def perform(op, box)
+    task.info("op: #{op}, box: #{box.contents}")
+  end
+
+end # Noise
+
+class FlowLogTest < ::Test::Unit::TestCase
+
+  # Make sure the log works and relays to a log task if it exists.
+  def test_flow_log_relay
+    trigger = nil
+    collector = nil
+    ::OFlow::Env.flow('log_relay') { |f|
+      trigger = f.task('noise', Noise)
+      f.task(:log, Collector) { |t|
+        collector = t.actor
+      }
+    }
+    trigger.receive(:speak, ::OFlow::Box.new(7))
+    ::OFlow::Env.flush()
+
+    assert_equal(collector.collection.size, 1)
+    assert_equal(collector.collection[0][0], 'op: speak, box: 7')
+    assert_equal(collector.collection[0][1], ':log_relay:noise')
+
+    ::OFlow::Env.clear()
+  end
+
+  # Make sure the log in the flow var is used.
+  def test_flow_log_var
+    trigger = nil
+    collector = nil
+    ::OFlow::Env.flow('log_relay') { |f|
+      trigger = f.task('noise', Noise)
+      f.log = f.task(:collector, Collector) { |t|
+        collector = t.actor
+      }
+    }
+    trigger.receive(:speak, ::OFlow::Box.new(7))
+    ::OFlow::Env.flush()
+
+    assert_equal(collector.collection.size, 1)
+    assert_equal(collector.collection[0][0], 'op: speak, box: 7')
+    assert_equal(collector.collection[0][1], ':log_relay:noise')
+
+    ::OFlow::Env.clear()
+  end
+
+  # Make sure the log in the Env var is used.
+  def test_flow_log_env
+    trigger = nil
+    collector = nil
+    ::OFlow::Env.flow('log_relay') { |f|
+      trigger = f.task('noise', Noise)
+      ::OFlow::Env.log = f.task(:collector, Collector) { |t|
+        collector = t.actor
+      }
+    }
+    trigger.receive(:speak, ::OFlow::Box.new(7))
+    ::OFlow::Env.flush()
+
+    assert_equal(collector.collection.size, 1)
+    assert_equal(collector.collection[0][0], 'op: speak, box: 7')
+    assert_equal(collector.collection[0][1], ':log_relay:noise')
+
+    ::OFlow::Env.clear()
+  end
+
+end # FlowLogTest