rworkflow 0.6.5 → 0.7.0

data/test/flow_test.rb

@@ -9,14 +9,14 @@ module Rworkflow
 
     def test_workflow
       lifecycle = Lifecycle.new do |lc|
-        lc.state("State1", {cardinality: 2}) do |state|
+        lc.state('State1', cardinality: 2) do |state|
           state.transition :pushed, Flow::STATE_SUCCESSFUL
           state.transition :failed, Flow::STATE_FAILED
         end
 
-        lc.initial = "State1"
+        lc.initial = 'State1'
       end
-      initial_objects = [1,2,3]
+      initial_objects = [1, 2, 3]
       workflow = Flow.create(lifecycle, 'myWorkflow')
       workflow_id = workflow.id
 
@@ -44,21 +44,21 @@ module Rworkflow
       end
 
       assert workflow.finished?
-      counters = workflow.get_counters
+      counters = workflow.counters
       assert_equal 2, counters[Flow::STATE_SUCCESSFUL]
       assert_equal 1, counters[Flow::STATE_FAILED]
 
-      assert_equal [1,3], workflow.list_objects(Flow::STATE_SUCCESSFUL)
+      assert_equal [1, 3], workflow.list_objects(Flow::STATE_SUCCESSFUL)
     end
 
     def test_flow_cardinality_all_started
       lifecycle = Lifecycle.new do |lc|
-        lc.state("State1", {cardinality: Lifecycle::CARDINALITY_ALL_STARTED}) do |state|
+        lc.state('State1', cardinality: Lifecycle::CARDINALITY_ALL_STARTED) do |state|
           state.transition :pushed, Flow::STATE_SUCCESSFUL
           state.transition :failed, Flow::STATE_FAILED
         end
 
-        lc.initial = "State1"
+        lc.initial = 'State1'
       end
 
       initial_objects = (1..6).to_a
@@ -70,17 +70,17 @@ module Rworkflow
     end
 
     def test_flow_state_policy_wait
-      initial_objects = [1,2,3,4]
+      initial_objects = [1, 2, 3, 4]
       lifecycle = Lifecycle.new do |lc|
-        lc.state("InitState", {cardinality: 1}) do |state|
-          state.transition :pushed, "WaitState"
+        lc.state('InitState', cardinality: 1) do |state|
+          state.transition :pushed, 'WaitState'
         end
 
-        lc.state("WaitState", {cardinality: initial_objects.size, priority: State::DEFAULT_PRIORITY, policy: State::STATE_POLICY_WAIT}) do |state|
+        lc.state('WaitState', cardinality: initial_objects.size, policy: State::STATE_POLICY_WAIT) do |state|
           state.transition :collected, Flow::STATE_SUCCESSFUL
         end
 
-        lc.initial = "InitState"
+        lc.initial = 'InitState'
       end
 
       workflow = Flow.create(lifecycle, 'myWorkflow')
@@ -93,7 +93,7 @@ module Rworkflow
         end
       end
 
-      workflow.fetch(1, 'WaitState') do |objects|
+      workflow.fetch(1, 'WaitState') do |_objects|
         # This block should not be executed
         assert false, 'The collector state should not be executed until there is enough waiting objects (>= cardinality)'
       end

data/test/lifecycle_test.rb

@@ -9,7 +9,7 @@ module Rworkflow
 
     def test_definition
       lifecycle = Lifecycle.new do |lc|
-        lc.state("State1") do |state|
+        lc.state('State1') do |state|
           state.transition :pushed, :successful
         end
 
@@ -17,22 +17,22 @@ module Rworkflow
       end
 
       assert_equal 'State1', lifecycle.initial
-      assert_equal :successful, lifecycle.transition("State1", :pushed)
-      assert_raises(Rworkflow::StateError) { lifecycle.transition("UnexistingState", :pushed) }
-      assert_raises(Rworkflow::TransitionError) { lifecycle.transition("State1", :non_existing_transition) }
+      assert_equal :successful, lifecycle.transition('State1', :pushed)
+      assert_raises(Rworkflow::StateError) { lifecycle.transition('UnexistingState', :pushed) }
+      assert_raises(Rworkflow::TransitionError) { lifecycle.transition('State1', :non_existing_transition) }
 
       lifecycle.default = Rworkflow::Flow::STATE_FAILED
       assert_equal Rworkflow::Flow::STATE_FAILED, lifecycle.default
-      assert_equal Rworkflow::Flow::STATE_FAILED, lifecycle.transition("State1", :non_existing_transition)
+      assert_equal Rworkflow::Flow::STATE_FAILED, lifecycle.transition('State1', :non_existing_transition)
     end
 
     def test_serialization
       lifecycle = Lifecycle.new do |lc|
-        lc.state("State1") do |state|
+        lc.state('State1') do |state|
           state.transition :pushed, :successful
         end
 
-        lc.initial = "State1"
+        lc.initial = 'State1'
       end
 
       serialized = lifecycle.serialize
@@ -40,21 +40,21 @@ module Rworkflow
       unserialized = Lifecycle.unserialize(serialized)
 
       assert_equal lifecycle.initial, unserialized.initial
-      assert_equal  Set.new(lifecycle.states.keys), Set.new(unserialized.states.keys)
-      assert lifecycle.states.all? {|name, state| unserialized.states[name].instance_eval{@transitions} == state.instance_eval{@transitions} }
+      assert_equal Set.new(lifecycle.states.keys), Set.new(unserialized.states.keys)
+      assert lifecycle.states.all? { |name, state| unserialized.states[name].instance_eval { @transitions } == state.instance_eval { @transitions } }
     end
 
     def test_concat
-      lifecycle_one = LCFactory.simple_lifecycle("1", :next)
-      lifecycle_two = LCFactory.simple_lifecycle("2", :finish)
+      lifecycle_one = LCFactory.simple_lifecycle('1', :next)
+      lifecycle_two = LCFactory.simple_lifecycle('2', :finish)
 
-      lifecycle_one.concat!("1", :next, lifecycle_two)
+      lifecycle_one.concat!('1', :next, lifecycle_two)
 
       assert_equal '1', lifecycle_one.initial
-      assert_equal '2', lifecycle_one.transition("1", :next)
-      assert_equal SidekiqFlow::STATE_SUCCESSFUL, lifecycle_one.transition("2", :finish)
+      assert_equal '2', lifecycle_one.transition('1', :next)
+      assert_equal SidekiqFlow::STATE_SUCCESSFUL, lifecycle_one.transition('2', :finish)
 
-      lifecycle_three = LCFactory.simple_lifecycle("3", :finish)
+      lifecycle_three = LCFactory.simple_lifecycle('3', :finish)
       lifecycle_three.state('1') do |s|
         s.transition(:next, '3')
         s.transition(:prev, '2')
@@ -67,9 +67,9 @@ module Rworkflow
     end
 
     class LCFactory
-      def self.simple_lifecycle(state_name, transition, cardinality = 1, priority = nil)
+      def self.simple_lifecycle(state_name, transition, cardinality = 1)
         return Rworkflow::Lifecycle.new do |cycle|
-          cycle.state(state_name, cardinality: cardinality, priority: priority) do |state|
+          cycle.state(state_name, cardinality: cardinality) do |state|
             state.transition transition, Rworkflow::SidekiqFlow::STATE_SUCCESSFUL
             state.transition :failed, Rworkflow::SidekiqFlow::STATE_FAILED
           end

data/test/sidekiq_flow_test.rb

@@ -9,20 +9,20 @@ module Rworkflow
 
     def test_lethal_workflow
       lifecycle = Lifecycle.new do |lc|
-        lc.state("Rworkflow::SidekiqFlowTest::Floating", {CARDINALITY_ALL_STARTEDality: 10}) do |state|
+        lc.state('Rworkflow::SidekiqFlowTest::Floating', cardinality: 10) do |state|
           state.transition :rescued, 'Rworkflow::SidekiqFlowTest::Lifeboat'
           state.transition :drowned, Rworkflow::Flow::STATE_FAILED
         end
-        lc.state("Rworkflow::SidekiqFlowTest::Lifeboat", {cardinality: 2}) do |state|
+        lc.state('Rworkflow::SidekiqFlowTest::Lifeboat', cardinality: 2) do |state|
           state.transition :landed, 'Rworkflow::SidekiqFlowTest::Land'
           state.transition :starved, Rworkflow::Flow::STATE_FAILED
         end
-        lc.state("Rworkflow::SidekiqFlowTest::Land") do |state|
+        lc.state('Rworkflow::SidekiqFlowTest::Land') do |state|
           state.transition :rescued, Rworkflow::Flow::STATE_SUCCESSFUL
           state.transition :died, Rworkflow::Flow::STATE_FAILED
         end
 
-        lc.initial = "Rworkflow::SidekiqFlowTest::Floating"
+        lc.initial = 'Rworkflow::SidekiqFlowTest::Floating'
       end
 
       initial_objects = (0...20).to_a
@@ -30,27 +30,27 @@ module Rworkflow
       workflow.start(initial_objects)
 
       assert workflow.finished?
-      counters = workflow.get_counters
+      counters = workflow.counters
       assert_equal 19, counters[Rworkflow::Flow::STATE_FAILED]
       assert_equal 1, counters[Rworkflow::Flow::STATE_SUCCESSFUL]
 
-      assert 2, RedisRds::String.new("Rworkflow::SidekiqFlowTest::Floating").get.to_i
-      assert 6, RedisRds::String.new("Rworkflow::SidekiqFlowTest::Lifeboat").get.to_i
-      assert 2, RedisRds::String.new("Rworkflow::SidekiqFlowTest::Land").get.to_i
+      assert 2, RedisRds::String.new('Rworkflow::SidekiqFlowTest::Floating').get.to_i
+      assert 6, RedisRds::String.new('Rworkflow::SidekiqFlowTest::Lifeboat').get.to_i
+      assert 2, RedisRds::String.new('Rworkflow::SidekiqFlowTest::Land').get.to_i
     end
 
     def test_pause_continue
       lifecycle = Lifecycle.new do |lc|
-        lc.state("Rworkflow::SidekiqFlowTest::Floating", {cardinality: 10}) do |state|
+        lc.state('Rworkflow::SidekiqFlowTest::Floating', cardinality: 10) do |state|
           state.transition :rescued, 'Rworkflow::SidekiqFlowTest::Lifeboat'
           state.transition :drowned, Rworkflow::Flow::STATE_FAILED
         end
-        lc.state("Rworkflow::SidekiqFlowTest::Lifeboat", {cardinality: 2}) do |state|
+        lc.state('Rworkflow::SidekiqFlowTest::Lifeboat', cardinality: 2) do |state|
           state.transition :landed, Rworkflow::Flow::STATE_SUCCESSFUL
           state.transition :starved, Rworkflow::Flow::STATE_FAILED
         end
 
-        lc.initial = "Rworkflow::SidekiqFlowTest::Floating"
+        lc.initial = 'Rworkflow::SidekiqFlowTest::Floating'
       end
 
       initial_objects = (0...20).to_a
@@ -65,25 +65,25 @@ module Rworkflow
       workflow.continue
       assert workflow.finished?
 
-      counters = workflow.get_counters
+      counters = workflow.counters
       assert_equal 18, counters[Rworkflow::Flow::STATE_FAILED]
       assert_equal 2, counters[Rworkflow::Flow::STATE_SUCCESSFUL]
 
-      assert 2, RedisRds::String.new("Rworkflow::SidekiqFlowTest::Floating").get.to_i
-      assert 6, RedisRds::String.new("Rworkflow::SidekiqFlowTest::Lifeboat").get.to_i
+      assert 2, RedisRds::String.new('Rworkflow::SidekiqFlowTest::Floating').get.to_i
+      assert 6, RedisRds::String.new('Rworkflow::SidekiqFlowTest::Lifeboat').get.to_i
     end
 
     def test_collector_state_workflow
       lifecycle = Lifecycle.new do |lc|
-        lc.state("Rworkflow::SidekiqFlowTest::PostcardSend", {cardinality: 1}) do |state|
+        lc.state('Rworkflow::SidekiqFlowTest::PostcardSend', cardinality: 1) do |state|
           state.transition :sent, 'Rworkflow::SidekiqFlowTest::PostcardCollector'
         end
 
-        lc.state("Rworkflow::SidekiqFlowTest::PostcardCollector", {cardinality: Lifecycle::CARDINALITY_ALL_STARTED, priority: State::DEFAULT_PRIORITY, policy: State::STATE_POLICY_WAIT}) do |state|
+        lc.state('Rworkflow::SidekiqFlowTest::PostcardCollector', cardinality: Lifecycle::CARDINALITY_ALL_STARTED, policy: State::STATE_POLICY_WAIT) do |state|
           state.transition :received, Rworkflow::Flow::STATE_SUCCESSFUL
         end
 
-        lc.initial = "Rworkflow::SidekiqFlowTest::PostcardSend"
+        lc.initial = 'Rworkflow::SidekiqFlowTest::PostcardSend'
       end
 
       initial_objects = (0...20).to_a
@@ -91,24 +91,24 @@ module Rworkflow
       workflow.start(initial_objects)
 
       assert workflow.finished?, 'Rworkflow finish successfully'
-      assert_equal 20, RedisRds::String.new("Rworkflow::SidekiqFlowTest::PostcardSend").get.to_i, 'All initial objects should be processed by the first state one by one'
-      assert_equal 1, RedisRds::String.new("Rworkflow::SidekiqFlowTest::PostcardSend_card").get.to_i, 'All initial objects should be processed by the first state one by one'
-      assert_equal 1, RedisRds::String.new("Rworkflow::SidekiqFlowTest::PostcardCollector").get.to_i, 'All initial objects should be processed by the collector state all at once'
-      assert_equal initial_objects.size, RedisRds::String.new("Rworkflow::SidekiqFlowTest::PostcardCollector_card").get.to_i, 'All initial objects should be processed by the collector state all at once'
+      assert_equal 20, RedisRds::String.new('Rworkflow::SidekiqFlowTest::PostcardSend').get.to_i, 'All initial objects should be processed by the first state one by one'
+      assert_equal 1, RedisRds::String.new('Rworkflow::SidekiqFlowTest::PostcardSend_card').get.to_i, 'All initial objects should be processed by the first state one by one'
+      assert_equal 1, RedisRds::String.new('Rworkflow::SidekiqFlowTest::PostcardCollector').get.to_i, 'All initial objects should be processed by the collector state all at once'
+      assert_equal initial_objects.size, RedisRds::String.new('Rworkflow::SidekiqFlowTest::PostcardCollector_card').get.to_i, 'All initial objects should be processed by the collector state all at once'
     end
 
     def test_gated
       lifecycle = Lifecycle.new do |lc|
-        lc.state("Rworkflow::SidekiqFlowTest::Floating", {cardinality: 10}) do |state|
+        lc.state('Rworkflow::SidekiqFlowTest::Floating', cardinality: 10) do |state|
           state.transition :rescued, 'Rworkflow::SidekiqFlowTest::Lifeboat'
           state.transition :drowned, Rworkflow::Flow::STATE_FAILED
         end
-        lc.state("Rworkflow::SidekiqFlowTest::Lifeboat", {cardinality: 2, policy: SidekiqFlow::STATE_POLICY_GATED}) do |state|
+        lc.state('Rworkflow::SidekiqFlowTest::Lifeboat', cardinality: 2, policy: SidekiqFlow::STATE_POLICY_GATED) do |state|
           state.transition :landed, Rworkflow::Flow::STATE_SUCCESSFUL
           state.transition :starved, Rworkflow::Flow::STATE_FAILED
         end
 
-        lc.initial = "Rworkflow::SidekiqFlowTest::Floating"
+        lc.initial = 'Rworkflow::SidekiqFlowTest::Floating'
       end
 
       initial_objects = (0...20).to_a
@@ -119,17 +119,17 @@ module Rworkflow
       workflow.open_gate('Rworkflow::SidekiqFlowTest::Lifeboat')
       assert workflow.finished?
 
-      counters = workflow.get_counters
+      counters = workflow.counters
       assert_equal 18, counters[Rworkflow::Flow::STATE_FAILED]
       assert_equal 2, counters[Rworkflow::Flow::STATE_SUCCESSFUL]
 
-      assert 2, RedisRds::String.new("Rworkflow::SidekiqFlowTest::Floating").get.to_i
-      assert 6, RedisRds::String.new("Rworkflow::SidekiqFlowTest::Lifeboat").get.to_i
+      assert 2, RedisRds::String.new('Rworkflow::SidekiqFlowTest::Floating').get.to_i
+      assert 6, RedisRds::String.new('Rworkflow::SidekiqFlowTest::Lifeboat').get.to_i
     end
 
     class Floating < Worker
       def process(objects)
-        rescued, drowned = objects.partition { |object| object.even? }
+        rescued, drowned = objects.partition(&:even?)
         transition(:rescued, rescued)
         transition(:drowned, drowned)
         RedisRds::String.new(self.class.name).incr

data/test/state_test.rb

@@ -36,10 +36,6 @@ module Rworkflow
       other_state.policy = State::STATE_POLICY_WAIT
       assert_not_equal @state, other_state, 'State A != B: different policies!'
 
-      other_state = State.new
-      other_state.priority = :high
-      assert_not_equal @state, other_state, 'State A != B: different priorities!'
-
       other_state = State.new
       other_state.cardinality = 32
       assert_not_equal @state, other_state, 'State A != B: different cardinalities!'
@@ -74,14 +70,13 @@ module Rworkflow
       @state.transition('a', 'b')
       @state.policy = State::STATE_POLICY_WAIT
       @state.cardinality = 2
-      @state.priority = :high
       cloned = @state.clone
       assert_equal @state, cloned, 'Original and cloned states should be equal'
       assert !@state.equal?(cloned), 'Original and cloned states should not be the same object'
     end
 
     def test_merge
-      other_state = State.new(cardinality: 2, priority: :high, policy: State::STATE_POLICY_WAIT)
+      other_state = State.new(cardinality: 2, policy: State::STATE_POLICY_WAIT)
       merged = @state.merge(other_state)
       assert_equal merged, other_state, 'Merged state should be equal to state B'
 

data/test/test_helper.rb

@@ -4,10 +4,10 @@ ENV['RAILS_ENV'] = 'test'
 require 'simplecov'
 require 'coveralls'
 
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
   SimpleCov::Formatter::HTMLFormatter,
   Coveralls::SimpleCov::Formatter
-]
+])
 SimpleCov.start
 
 require File.expand_path('../dummy/config/environment.rb', __FILE__)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rworkflow
 version: !ruby/object:Gem::Version
-  version: 0.6.5
+  version: 0.7.0
 platform: ruby
 authors:
 - barcoo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-20 00:00:00.000000000 Z
+date: 2017-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -66,7 +66,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
-description: 'TBC: Description of Rworkflow.'
+description: rworkflow - workflow framework for Ruby
 email:
 - roots@checkitmobile.com
 executables: []
@@ -74,6 +74,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - MIT-LICENSE
+- README.md
 - Rakefile
 - lib/rworkflow.rb
 - lib/rworkflow/configuration.rb
@@ -92,7 +93,6 @@ files:
 - lib/rworkflow/transition_error.rb
 - lib/rworkflow/version.rb
 - lib/rworkflow/worker.rb
-- lib/tasks/rworkflow_tasks.rake
 - test/dummy/README.rdoc
 - test/dummy/Rakefile
 - test/dummy/app/assets/javascripts/application.js
@@ -129,11 +129,10 @@ files:
 - test/dummy/public/favicon.ico
 - test/flow_test.rb
 - test/lifecycle_test.rb
-- test/rworkflow_test.rb
 - test/sidekiq_flow_test.rb
 - test/state_test.rb
 - test/test_helper.rb
-homepage: https://www.barcoo.com
+homepage: https://github.com/barcoo/rworkflow
 licenses:
 - MIT
 metadata: {}
@@ -156,7 +155,7 @@ rubyforge_project:
 rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
-summary: 'TBC: Summary of Rworkflow.'
+summary: rworkflow - workflow framework for Ruby
 test_files:
 - test/dummy/app/assets/javascripts/application.js
 - test/dummy/app/assets/stylesheets/application.css
@@ -194,7 +193,6 @@ test_files:
 - test/dummy/README.rdoc
 - test/flow_test.rb
 - test/lifecycle_test.rb
-- test/rworkflow_test.rb
 - test/sidekiq_flow_test.rb
 - test/state_test.rb
 - test/test_helper.rb

data/lib/tasks/rworkflow_tasks.rake

@@ -1,4 +0,0 @@
-# desc "Explaining what the task does"
-# task :rworkflow do
-#   # Task goes here
-# end

data/test/rworkflow_test.rb

@@ -1,7 +0,0 @@
-require 'test_helper'
-
-class RworkflowTest < ActiveSupport::TestCase
-  test "truth" do
-    assert_kind_of Module, Rworkflow
-  end
-end