oflow 0.6.0 → 0.8.0

data/test/flow_rescue_test.rb

@@ -1,11 +1,9 @@
 #!/usr/bin/env ruby
 # encoding: UTF-8
 
-[ File.dirname(__FILE__),
-  File.join(File.dirname(__FILE__), "../lib")
-].each { |path| $: << path unless $:.include?(path) }
+$: << File.dirname(__FILE__) unless $:.include? File.dirname(__FILE__)
 
-require 'test/unit'
+require 'helper'
 require 'oflow'
 
 require 'collector'
@@ -21,14 +19,15 @@ class Crash < ::OFlow::Actor
 
 end # Crash
 
-class FlowRescueTest < ::Test::Unit::TestCase
+class FlowRescueTest < ::MiniTest::Test
 
   # Make sure the error handler works and forwards to the 'error' task if it
   # exists.
   def test_flow_rescue_task
+    env = ::OFlow::Env.new('')
     trigger = nil
     collector = nil
-    ::OFlow::Env.flow('rescue') { |f|
+    env.flow('rescue') { |f|
       trigger = f.task('crash', Crash)
       f.task(:collector, Collector) { |t|
         collector = t.actor
@@ -40,21 +39,25 @@ class FlowRescueTest < ::Test::Unit::TestCase
         t.link(nil, 'collector', 'log')
       }
     }
+    env.prepare()
+    env.start()
+
     trigger.receive(:knock, ::OFlow::Box.new(7))
-    ::OFlow::Env.flush()
+    env.flush()
 
-    assert_equal(collector.collection.size, 1)
-    assert_equal(collector.collection[0][0].class, NoMethodError)
-    assert_equal(collector.collection[0][1], ':rescue:crash')
+    assert_equal(1, collector.collection.size)
+    assert_equal(NoMethodError, collector.collection[0][0].class)
+    assert_equal('rescue:crash', collector.collection[0][1])
 
-    ::OFlow::Env.clear()
+    env.clear()
   end
 
   # Make sure the error handler on the flow is used to handle errors.
   def test_flow_rescue_var
+    env = ::OFlow::Env.new('')
     trigger = nil
     collector = nil
-    ::OFlow::Env.flow('rescue') { |f|
+    env.flow('rescue') { |f|
       trigger = f.task('crash', Crash)
       f.error_handler = f.task(:collector, Collector) { |t|
         collector = t.actor
@@ -63,51 +66,62 @@ class FlowRescueTest < ::Test::Unit::TestCase
         t.link(nil, 'collector', 'log')
       }
     }
+    env.prepare()
+    env.start()
+
     trigger.receive(:knock, ::OFlow::Box.new(7))
-    ::OFlow::Env.flush()
+    env.flush()
 
-    assert_equal(collector.collection.size, 1)
-    assert_equal(collector.collection[0][0].class, NoMethodError)
-    assert_equal(collector.collection[0][1], ':rescue:crash')
+    assert_equal(1, collector.collection.size)
+    assert_equal(NoMethodError, collector.collection[0][0].class)
+    assert_equal('rescue:crash', collector.collection[0][1])
 
-    ::OFlow::Env.clear()
+    env.clear()
   end
 
   # Make sure the error handler on the flow is used to handle errors.
   def test_flow_rescue_env
+    env = ::OFlow::Env.new('')
     trigger = nil
     collector = nil
-    ::OFlow::Env.flow('rescue') { |f|
+    env.flow('rescue') { |f|
       trigger = f.task('crash', Crash)
-      ::OFlow::Env.error_handler = f.task(:collector, Collector) { |t|
+      env.error_handler = f.task(:collector, Collector) { |t|
         collector = t.actor
       }
       f.task(:log, ::OFlow::Actors::Relay) { |t|
         t.link(nil, 'collector', 'log')
       }
     }
+    env.prepare()
+    env.start()
+
     trigger.receive(:knock, ::OFlow::Box.new(7))
-    ::OFlow::Env.flush()
+    env.flush()
 
     assert_equal(1, collector.collection.size)
     assert_equal(NoMethodError, collector.collection[0][0].class)
-    assert_equal(':rescue:crash', collector.collection[0][1])
+    assert_equal('rescue:crash', collector.collection[0][1])
 
-    ::OFlow::Env.clear()
+    env.clear()
   end
 
   # Make sure the default error handler on the flow passes a message to the log.
   def test_flow_rescue_env_log
+    env = ::OFlow::Env.new('')
     trigger = nil
     collector = nil
-    ::OFlow::Env.flow('rescue') { |f|
+    env.flow('rescue') { |f|
       trigger = f.task('crash', Crash)
-      ::OFlow::Env.log = f.task(:collector, Collector) { |t|
+      env.log = f.task(:collector, Collector) { |t|
         collector = t.actor
       }
     }
+    env.prepare()
+    env.start()
+
     trigger.receive(:knock, ::OFlow::Box.new(7))
-    ::OFlow::Env.flush()
+    env.flush()
 
     assert_equal(1, collector.collection.size)
     assert_equal(["NoMethodError: undefined method `crash' for nil:NilClass",
@@ -115,9 +129,9 @@ class FlowRescueTest < ::Test::Unit::TestCase
                   "/task.rb:0:in `block in initialize'"],
                  simplify(collector.collection[0][0]))
 
-    assert_equal(':rescue:crash', collector.collection[0][1])
+    assert_equal('rescue:crash', collector.collection[0][1])
 
-    ::OFlow::Env.clear()
+    env.clear()
   end
 
   def simplify(bt)

data/test/flow_tracker_test.rb

@@ -1,11 +1,9 @@
 #!/usr/bin/env ruby
 # encoding: UTF-8
 
-[ File.dirname(__FILE__),
-  File.join(File.dirname(__FILE__), "../lib")
-].each { |path| $: << path unless $:.include?(path) }
+$: << File.dirname(__FILE__) unless $:.include? File.dirname(__FILE__)
 
-require 'test/unit'
+require 'helper'
 require 'oflow'
 
 require 'collector'
@@ -36,47 +34,45 @@ class Catch < ::OFlow::Actor
 
 end # Catch
 
-class FlowTrackerTest < ::Test::Unit::TestCase
+class FlowTrackerTest < ::MiniTest::Test
 
   def test_flow_tracker
+    env = ::OFlow::Env.new('')
     trigger = nil
     catcher = nil
-    ::OFlow::Env.flow(:nest, :opt1 => 1) { |f|
-
+    env.flow(:prime) { |f|
       # starts off the process
       trigger = f.task(:trigger, Throw) { |t|
-        t.link(nil, :deep, nil)
-      }
-      # a nested flow
-      f.flow(:deep) { |f2|
-        f2.route(nil, :one, nil)
-        f2.task(:one, Throw) { |t|
-          t.link(nil, :two, nil)
-        }
-        f2.task(:two, Throw) { |t|
-          t.link(nil, :flow, :bye)
-        }
-        f2.link(:bye, :out, nil)
+        t.link(nil, :one, nil, :deep)
       }
-      f.task(:out, Throw) { |t|
+      f.task(:in, Throw) { |t|
           t.link(nil, :done, nil)
       }
       catcher = f.task(:done, Catch)
     }
+    env.flow(:deep) { |f|
+      f.task(:one, Throw) { |t|
+        t.link(nil, :two, nil)
+      }
+      f.task(:two, Throw) { |t|
+        t.link(nil, :in, :bye, :prime)
+      }
+    }
+
+    env.prepare()
+    env.start()
 
     # run it and check the output
     trigger.receive(:go, ::OFlow::Box.new(7, ::OFlow::Tracker.create('test')))
-    ::OFlow::Env.flush()
+    env.flush()
     assert_equal(["test-",
-                  ":nest:trigger-go",
-                  ":nest:deep-",
-                  ":nest:deep:one-",
-                  ":nest:deep:two-",
-                  ":nest:deep-bye",
-                  ":nest:out-",
-                  ":nest:done-"], catcher.actor.ball.tracker.track.map {|s| s.where })
-
-    ::OFlow::Env.clear()
+                  "prime:trigger-go",
+                  "deep:one-",
+                  "deep:two-",
+                  "prime:in-bye",
+                  "prime:done-"], catcher.actor.ball.tracker.track.map {|s| s.where })
+
+    env.clear()
   end
 
 end # FlowTrackerTest

data/test/helper.rb

@@ -0,0 +1,15 @@
+
+$VERBOSE = true
+
+[ File.dirname(__FILE__),
+  File.join(File.dirname(__FILE__), "../lib"),
+  File.join(File.dirname(__FILE__), "../../oj/ext"),
+  File.join(File.dirname(__FILE__), "../../oj/lib"),
+  File.join(File.dirname(__FILE__), "../../ox/ext"),
+  File.join(File.dirname(__FILE__), "../../ox/lib"),
+  File.join(File.dirname(__FILE__), "../../oterm/lib"),
+].each { |path| $: << path unless $:.include?(path) }
+
+require 'minitest'
+require 'minitest/unit'
+require 'minitest/autorun'

data/test/task_test.rb

@@ -1,11 +1,7 @@
 #!/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 'helper'
 require 'oflow'
 
 class Gather < ::OFlow::Actor
@@ -27,7 +23,7 @@ class Gather < ::OFlow::Actor
 end # Gather
 
 
-class TaskTest < ::Test::Unit::TestCase
+class TaskTest < ::MiniTest::Test
 
   def test_task_queue_count
     task = ::OFlow::Task.new(nil, 'test', Gather)
@@ -72,7 +68,7 @@ class TaskTest < ::Test::Unit::TestCase
   def test_task_raise_after_close
     task = ::OFlow::Task.new(nil, 'test', Gather)
     task.shutdown()
-    assert_raise(ThreadError) { task.start() }
+    assert_raises(ThreadError) { task.start() }
   end
 
   def test_task_max_queue_count

data/test/tracker_test.rb

@@ -1,24 +1,16 @@
 #!/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 'helper'
 require 'oflow'
 
-class TrackerTest < ::Test::Unit::TestCase
+class TrackerTest < ::MiniTest::Test
 
   def test_tracker_new
     t = ::OFlow::Tracker.create('here')
     t2 = ::OFlow::Tracker.create('here')
 
-    assert_not_equal(t.id, t2.id, 'id must be unique')
+    refute_equal(t.id, t2.id, 'id must be unique')
     assert_equal('here', t.track[0].location)
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: oflow
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Peter Ohler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-13 00:00:00.000000000 Z
+date: 2014-12-22 00:00:00.000000000 Z
 dependencies: []
 description: Operations Workflow in Ruby. This implements a workflow/process flow
   using multiple task nodes that each have their own queues and execution thread.
@@ -37,11 +37,9 @@ files:
 - lib/oflow/env.rb
 - lib/oflow/errors.rb
 - lib/oflow/flow.rb
+- lib/oflow/graffle.rb
 - lib/oflow/haserrorhandler.rb
-- lib/oflow/haslinks.rb
 - lib/oflow/haslog.rb
-- lib/oflow/hasname.rb
-- lib/oflow/hastasks.rb
 - lib/oflow/inspector.rb
 - lib/oflow/link.rb
 - lib/oflow/pattern.rb
@@ -64,17 +62,17 @@ files:
 - test/collector.rb
 - test/flow_basic_test.rb
 - test/flow_cfg_error_test.rb
+- test/flow_linked_test.rb
 - test/flow_log_test.rb
-- test/flow_nest_test.rb
 - test/flow_rescue_test.rb
 - test/flow_tracker_test.rb
+- test/helper.rb
 - test/stutter.rb
 - test/task_test.rb
 - test/tracker_test.rb
 homepage: http://www.ohler.com/oflow
 licenses:
 - MIT
-- GPL-3.0
 metadata: {}
 post_install_message: 
 rdoc_options:

data/lib/oflow/haslinks.rb

@@ -1,68 +0,0 @@
-
-module OFlow
-
-  # Adds support for Links. Used by Flow and Env.
-  module HasLinks
-
-    # Sets up the links attribute.
-    def init_links()
-      @links = {}
-    end
-
-    # Creates a Link identified by the label that has a target Task or Flow and
-    # operation.
-    # @param label [Symbol|String] identifer of the Link
-    # @param target [Symbol|String] identifer of the target Task
-    # @param op [Symbol|String] operation to perform on the target Task
-    def link(label, target, op)
-      label = label.to_sym unless label.nil?
-      op = op.to_sym unless op.nil?
-      raise ConfigError.new("Link #{label} already exists.") unless @links[label].nil?
-      label = label.to_sym unless label.nil?
-      @links[label] = Link.new(target.to_sym, op)
-    end
-
-    # Attempts to find and resolve the Link identified by the label. Resolving a
-    # Link uses the target identifier to find the target Task and save that in
-    # the Link.
-    # @param label [Symbol|String] identifer of the Link
-    # @return [Link] returns the Link for the label
-    def resolve_link(label)
-      label = label.to_sym unless label.nil?
-      lnk = @links[label] || @links[nil]
-      return nil if lnk.nil?
-      set_link_target(lnk) if lnk.target.nil?
-      lnk
-    end
-
-    # Sets the target Task for a Link.
-    # @param lnk [Link] Link to find the target Task for.
-    def set_link_target(lnk)
-        if lnk.ingress
-          task = find_task(lnk.target_name)
-        else
-          task = @flow.find_task(lnk.target_name)
-        end
-        lnk.instance_variable_set(:@target, task)
-    end
-
-    # Attempts to find the Link identified by the label.
-    # @param label [Symbol|String] identifer of the Link
-    # @return [Link] returns the Link for the label
-    def find_link(label)
-      label = label.to_sym unless label.nil?
-      @links[label] || @links[nil]
-    end
-
-    # Returns the Links.
-    # @return [Hash] Hash of Links with the keys as Symbols that are the labels of the Links.
-    def links()
-      @links
-    end
-
-    def has_links?()
-      !@links.nil? && !@links.empty?
-    end
-
-  end # HasLinks
-end # OFlow

data/lib/oflow/hasname.rb

@@ -1,31 +0,0 @@
-
-module OFlow
-
-  # Adds support for a name attribute and the ability to form full name for a
-  # named item.
-  module HasName
-    # The name.
-    attr_reader :name
-
-    # The containing Flow is used to support the full_name() method otherwise it
-    # just sets the name.
-    # @param flow [Flow|Env] containing Flow
-    # @param name [Symbol|String] base name
-    def init_name(flow, name)
-      @flow = flow
-      @name = name.to_sym
-    end
-
-    # Similar to a full file path. The full_name described the containment of
-    # the named item.
-    # @return [String] full name of item
-    def full_name()
-      if @flow.respond_to?(:full_name)
-        @flow.full_name() + ':' + @name.to_s
-      else
-        @name.to_s
-      end
-    end
-
-  end # HasName
-end # OFlow