weel 1.99.81 → 1.99.83

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71b00df67a5ce45cc411d04bdcb57c0c2add9a37bf73df697dc13a19d57edff1
-  data.tar.gz: fa82207e6df3ba11c89b2fb661d0ffe2e801b0dee91674b9aabff2a6406ebd37
+  metadata.gz: 05367a0dcc8066aeb8180358efed5612c976b7b97e5ea8f5047a83bc482de8ff
+  data.tar.gz: 87a40bbb853caf454d43a8632e9d2535b4cdcfab040bf2490095dbdcbea2123f
 SHA512:
-  metadata.gz: 394ffac0c9bbb8777417254ff890735d3460d82a3657b21c563663770d1d2341e710a18cb768db5ae35a9978b521c617086f7bb68654c824299c3fc74dc6a57f
-  data.tar.gz: 249881015b74398a230ae218403267ea0276597cc380d19649b1f794970aaa63ba87f0122a42dee5d61b3bdbe3870a97a7db1c1afd21391b84d79a8f940b9c3d
+  metadata.gz: b90f1b6a44a0ef9e47a60a8cd1da7f904691377859fd7aab2bcf19b100e1de7eea1534235944060b5101f6836c7c307e868db8828b26cbc9b5363dbb6d10012e
+  data.tar.gz: '077059c2ad549cf6bb0debe569c9bed27b94c5e02c248a0b8662b457c014d726b38924b593b5005abf29dee60cb7b7de164dabcdabb6893ab39c6496319b2634'

data/README.md

@@ -0,0 +1,35 @@
+All code in this package is provided under the LGPL-3 license.
+Please read the file COPYING.
+
+Tested for MRI 2.6, 2.7
+
+# Example Process (DSL)
+
+```ruby
+class SimpleWorkflow < WEEL
+  handlerwrapper SimpleHandlerWrapper
+
+  endpoint :ep1 => "orf.at"
+  data :a => 17
+
+  control flow do
+    call :a1, :ep1, parameters: { :a => data.a, :b => 2 } do
+      data.a += 3
+    end
+  end
+end
+```
+
+HandlerWrappers are classes that implement communication protocols. Endpoints hold the communication targets and can be reused throughout the control flow. Data elements are control flow scoped variables.
+
+Please check out the "example" directory to see a minimal set of necessary artefacts.
+
+# Further Reading
+
+For an evaluation and description of all available control flow statements, see https://arxiv.org/pdf/1003.3330.pdf.
+
+# Installation
+
+```bash
+gem install weel
+```

data/lib/weel.rb

@@ -40,33 +40,43 @@ class WEEL
     class Salvage < Exception; end
   end # }}}
 
-class ReadStructure # {{{
-  def initialize(data,endpoints)
-    @__weel_data = data.dup
-    @__weel_data.transform_values! do |v|
-      if Object.const_defined?(:XML) && XML.const_defined?(:Smart) && v.is_a?(XML::Smart::Dom)
-        v.root.to_doc
-      else
+  class ReadStructure # {{{
+    def initialize(data,endpoints,additional)
+      @__weel_data = data.dup
+      @__weel_data.transform_values! do |v|
+        if Object.const_defined?(:XML) && XML.const_defined?(:Smart) && v.is_a?(XML::Smart::Dom)
+          v.root.to_doc
+        else
+          begin
+            Marshal.load(Marshal.dump(v))
+          rescue
+            v.to_s rescue nil
+          end
+        end
+      end
+      @__weel_endpoints = endpoints.dup
+      @__weel_endpoints.transform_values!{ |v| v.dup }
+      @additional = additional
+    end
+
+    def method_missing(m,args,&block)
+      if @additional.exists?(m)
         begin
-          Marshal.load(Marshal.dump(v))
+          Marshal.load(Marshal.dump(@aditional[m]))
         rescue
           v.to_s rescue nil
         end
       end
     end
-    @__weel_endpoints = endpoints.dup
-    @__weel_endpoints.transform_values!{ |v| v.dup }
-  end
-
-  def data
-    ReadHash.new(@__weel_data)
-  end
-  def endpoints
-    ReadHash.new(@__weel_endpoints)
-  end
-end # }}}
+    def data
+      ReadHash.new(@__weel_data)
+    end
+    def endpoints
+      ReadHash.new(@__weel_endpoints)
+    end
+  end # }}}
   class ManipulateStructure # {{{
-    def initialize(data,endpoints,status)
+    def initialize(data,endpoints,status,additional)
       @__weel_data = data
       @__weel_data_orig = @__weel_data.transform_values{|val| Marshal.dump(val) } rescue nil
       @__weel_endpoints = endpoints
@@ -77,6 +87,17 @@ end # }}}
       @touched_data = []
       @changed_endpoints = []
       @touched_endpoints = []
+      @additional = additional
+    end
+
+    def method_missing(m,args,&block)
+      if @additional.exists?(m)
+        begin
+          Marshal.load(Marshal.dump(@aditional[m]))
+        rescue
+          v.to_s rescue nil
+        end
+      end
     end
 
     def changed_data
@@ -209,17 +230,18 @@ end # }}}
     def self::inform_state_change(arguments,newstate); end
     def self::inform_syntax_error(arguments,err,code); end
     def self::inform_handlerwrapper_error(arguments,err); end
-    def self::inform_position_change(arguments,ipc); end
-    def self::modify_position_details(arguments); end
+    def self::inform_position_change(arguments,ipc={}); end
 
-    def initialize(arguments,endpoint=nil,position=nil,continue=nil); end
+    def initialize(arguments,position=nil,continue=nil); end
 
     def prepare(readonly, endpoints, parameters, replay=false); parameters; end
+    def additional; {}; end
 
     def activity_handle(passthrough, parameters); end
     def activity_manipulate_handle(parameters); end
 
     def activity_result_value; end
+    def activity_result_options; end
 
     def activity_stop; end
     def activity_passthrough_value; end
@@ -364,8 +386,8 @@ end # }}}
     # Parallel DSL-Construct
     # Defines Workflow paths that can be executed parallel.
     # May contain multiple branches (parallel_branch)
-    def parallel(type=nil)# {{{
-      return if self.__weel_state == :stopping || self.__weel_state == :finishing || self.__weel_state == :stopped || Thread.current[:nolongernecessary]
+    def parallel(type=nil,&block)# {{{
+      return if self.__weel_state == :stopping || self.__weel_state == :finishing || self.__weel_state == :stopped
 
       Thread.current[:branches] = []
       Thread.current[:branch_finished_count] = 0
@@ -374,7 +396,7 @@ end # }}}
 
       hw, pos = __weel_sim_start(:parallel) if __weel_sim
 
-      __weel_protect_yield(&Proc.new)
+      __weel_protect_yield(&block)
 
       Thread.current[:branch_wait_count] = (type.is_a?(Hash) && type.size == 1 && type[:wait] != nil && (type[:wait].is_a?(Integer) && type[:wait] > 0) ? type[:wait] : Thread.current[:branches].size)
       1.upto Thread.current[:branches].size do
@@ -387,10 +409,10 @@ end # }}}
         if Thread.current[:branch_search] == false
           thread[:branch_search] = false
         end
-        thread[:start_event].continue
+        thread[:start_event]&.continue # sometimes start event might not even exist yet (i.e. race condition)
       end
 
-      Thread.current[:branch_event].wait
+      Thread.current[:branch_event].wait unless self.__weel_state == :stopping || self.__weel_state == :finishing || self.__weel_state == :stopped
 
       __weel_sim_stop(:parallel,hw,pos) if __weel_sim
 
@@ -410,7 +432,7 @@ end # }}}
     end # }}}
 
     # Defines a branch of a parallel-Construct
-    def parallel_branch(*vars)# {{{
+    def parallel_branch(*vars,&block)# {{{
       return if self.__weel_state == :stopping || self.__weel_state == :finishing || self.__weel_state == :stopped || Thread.current[:nolongernecessary]
       branch_parent = Thread.current
 
@@ -436,14 +458,16 @@ end # }}}
           Thread.current[:alternative_mode] = [branch_parent[:alternative_mode].last]
         end
         branch_parent[:branch_event].continue
-        Thread.current[:start_event].wait
+        Thread.current[:start_event].wait unless self.__weel_state == :stopping || self.__weel_state == :stopped || self.__weel_state == :finishing
 
         if __weel_sim
           handlerwrapper = @__weel_handlerwrapper.new @__weel_handlerwrapper_args
           handlerwrapper.simulate(:parallel_branch,:start,Thread.current[:branch_sim_pos],current_branch_sim_pos)
         end
 
-        __weel_protect_yield(*local, &Proc.new)
+        unless self.__weel_state == :stopping || self.__weel_state == :finishing || self.__weel_state == :stopped || Thread.current[:nolongernecessary]
+          __weel_protect_yield(*local, &block)
+        end
 
         __weel_sim_stop(:parallel_branch,handlerwrapper,current_branch_sim_pos) if __weel_sim
 
@@ -454,7 +478,7 @@ end # }}}
             branch_parent[:branch_event].continue
           end
         end
-        if self.__weel_state != :stopping && self.__weel_state != :stopped && self.__weel_state != :finishing
+        unless self.__weel_state == :stopping || self.__weel_state == :stopped || self.__weel_state == :finishing
           if Thread.current[:branch_position]
             @__weel_positions.delete Thread.current[:branch_position]
             begin
@@ -471,14 +495,14 @@ end # }}}
     # Choose DSL-Construct
     # Defines a choice in the Workflow path.
     # May contain multiple execution alternatives
-    def choose(mode=:inclusive) # {{{
+    def choose(mode=:inclusive,&block) # {{{
       return if self.__weel_state == :stopping || self.__weel_state == :finishing || self.__weel_state == :stopped || Thread.current[:nolongernecessary]
       Thread.current[:alternative_executed] ||= []
       Thread.current[:alternative_mode] ||= []
       Thread.current[:alternative_executed] << false
       Thread.current[:alternative_mode] << mode
       hw, pos = __weel_sim_start(:choose,:mode => Thread.current[:alternative_mode].last) if __weel_sim
-      __weel_protect_yield(&Proc.new)
+      __weel_protect_yield(&block)
       __weel_sim_stop(:choose,hw,pos,:mode => Thread.current[:alternative_mode].last) if __weel_sim
       Thread.current[:alternative_executed].pop
       Thread.current[:alternative_mode].pop
@@ -488,7 +512,7 @@ end # }}}
     # Defines a possible choice of a choose-Construct
     # Block is executed if condition == true or
     # searchmode is active (to find the starting position)
-    def alternative(condition,args={})# {{{
+    def alternative(condition,args={},&block)# {{{
       return if self.__weel_state == :stopping || self.__weel_state == :finishing || self.__weel_state == :stopped || Thread.current[:nolongernecessary]
       hw, pos = __weel_sim_start(:alternative,args.merge(:mode => Thread.current[:alternative_mode].last, :condition => ((condition.is_a?(String) || condition.is_a?(Proc)) ? condition : nil))) if __weel_sim
       Thread.current[:mutex] ||= Mutex.new
@@ -499,18 +523,18 @@ end # }}}
         end
         Thread.current[:alternative_executed][-1] = true if condition
       end
-      __weel_protect_yield(&Proc.new) if __weel_is_in_search_mode || __weel_sim || condition
+      __weel_protect_yield(&block) if __weel_is_in_search_mode || __weel_sim || condition
       __weel_sim_stop(:alternative,hw,pos,args.merge(:mode => Thread.current[:alternative_mode].last, :condition => ((condition.is_a?(String) || condition.is_a?(Proc)) ? condition : nil))) if __weel_sim
     end # }}}
-    def otherwise(args={}) # {{{
+    def otherwise(args={},&block) # {{{
       return if self.__weel_state == :stopping || self.__weel_state == :finishing || self.__weel_state == :stopped || Thread.current[:nolongernecessary]
       hw, pos = __weel_sim_start(:otherwise,args.merge(:mode => Thread.current[:alternative_mode].last)) if __weel_sim
-      __weel_protect_yield(&Proc.new) if __weel_is_in_search_mode || __weel_sim || !Thread.current[:alternative_executed].last
+      __weel_protect_yield(&block) if __weel_is_in_search_mode || __weel_sim || !Thread.current[:alternative_executed].last
       __weel_sim_stop(:otherwise,hw,pos,args.merge(:mode => Thread.current[:alternative_mode].last)) if __weel_sim
     end # }}}
 
     # Defines a critical block (=Mutex)
-    def critical(id)# {{{
+    def critical(id,&block)# {{{
       @__weel_critical ||= Mutex.new
       semaphore = nil
       @__weel_critical.synchronize do
@@ -519,19 +543,19 @@ end # }}}
         @__weel_critical_sections[id] = semaphore if id
       end
       semaphore.synchronize do
-        __weel_protect_yield(&Proc.new)
+        __weel_protect_yield(&block)
       end
     end # }}}
 
     # Defines a Cycle (loop/iteration)
-    def loop(condition,args={})# {{{
+    def loop(condition,args={},&block)# {{{
       unless condition.is_a?(Array) && (condition[0].is_a?(Proc) || condition[0].is_a?(String)) && [:pre_test,:post_test].include?(condition[1]) && args.is_a?(Hash)
         raise "condition must be called pre_test{} or post_test{}"
       end
       return if self.__weel_state == :stopping || self.__weel_state == :finishing || self.__weel_state == :stopped || Thread.current[:nolongernecessary]
       if __weel_is_in_search_mode
         catch :escape do
-          __weel_protect_yield(&Proc.new)
+          __weel_protect_yield(&block)
         end
         if __weel_is_in_search_mode
           return
@@ -545,7 +569,7 @@ end # }}}
         cond = condition[0].is_a?(Proc) ? true : condition[0]
         hw, pos = __weel_sim_start(:loop,args.merge(:testing=>condition[1],:condition=>cond))
         catch :escape do
-          __weel_protect_yield(&Proc.new)
+          __weel_protect_yield(&block)
         end
         __weel_sim_stop(:loop,hw,pos,args.merge(:testing=>condition[1],:condition=>cond))
         return
@@ -554,11 +578,11 @@ end # }}}
         case condition[1]
           when :pre_test
             while __weel_eval_condition(condition[0]) && self.__weel_state != :stopping && self.__weel_state != :stopped && self.__weel_state != :finishing
-              __weel_protect_yield(&Proc.new)
+              __weel_protect_yield(&block)
             end
           when :post_test
             begin
-              __weel_protect_yield(&Proc.new)
+              __weel_protect_yield(&block)
             end while __weel_eval_condition(condition[0]) && self.__weel_state != :stopping && self.__weel_state != :stopped && self.__weel_state != :finishing
         end
       end
@@ -620,7 +644,7 @@ end # }}}
     def __weel_eval_condition(condition) #{{{
       begin
         handlerwrapper = @__weel_handlerwrapper.new @__weel_handlerwrapper_args unless condition.is_a?(Proc)
-        condition.is_a?(Proc) ? condition.call : handlerwrapper.test_condition(ReadStructure.new(@__weel_data,@__weel_endpoints),condition)
+        condition.is_a?(Proc) ? condition.call : handlerwrapper.test_condition(ReadStructure.new(@__weel_data,@__weel_endpoints,handlerwrapper.additional),condition)
       rescue NameError => err # don't look into it, or it will explode
         # if you access $! here, BOOOM
         self.__weel_state = :stopping
@@ -689,10 +713,10 @@ end # }}}
               handlerwrapper.activity_manipulate_handle(parameters)
               handlerwrapper.inform_activity_manipulate
               if finalize.is_a?(Proc)
-                mr = ManipulateStructure.new(@__weel_data,@__weel_endpoints,@__weel_status)
+                mr = ManipulateStructure.new(@__weel_data,@__weel_endpoints,@__weel_status,handlerwrapper.additional)
                 mr.instance_eval(&finalize)
               elsif finalize.is_a?(String)
-                mr = ManipulateStructure.new(@__weel_data,@__weel_endpoints,@__weel_status)
+                mr = ManipulateStructure.new(@__weel_data,@__weel_endpoints,@__weel_status,handlerwrapper.additional)
                 handlerwrapper.manipulate(mr,finalize)
               end
               handlerwrapper.inform_manipulate_change(
@@ -709,10 +733,10 @@ end # }}}
           when :call
             begin
               again = catch Signal::Again do
-                rs = ReadStructure.new(@__weel_data,@__weel_endpoints)
+                rs = ReadStructure.new(@__weel_data,@__weel_endpoints,handlerwrapper.additional)
                 if prepare
                   if prepare.is_a?(Proc)
-                    rs.instance_exec &prepare
+                    rs.instance_exec(&prepare)
                   elsif prepare.is_a?(String)
                     rs.instance_eval prepare
                   end
@@ -759,18 +783,18 @@ end # }}}
                   if code.is_a?(Proc) || code.is_a?(String)
                     handlerwrapper.inform_activity_manipulate
                     if code.is_a?(Proc)
-                      mr = ManipulateStructure.new(@__weel_data,@__weel_endpoints,@__weel_status)
-                      case code.arity
-                        when 1; mr.instance_exec(handlerwrapper.activity_result_value,&code)
-                        when 2; mr.instance_exec(handlerwrapper.activity_result_value,&code)
-                        else
-                          ma = catch Signal::Again do
+                      mr = ManipulateStructure.new(@__weel_data,@__weel_endpoints,@__weel_status,handlerwrapper.additional)
+                      ma = catch Signal::Again do
+                        case code.arity
+                          when 1; mr.instance_exec(handlerwrapper.activity_result_value,&code)
+                          when 2; mr.instance_exec(handlerwrapper.activity_result_value,&code)
+                          else
                             mr.instance_exec(&code)
-                            'yes' # ma sadly will have nil when i just throw
-                          end
+                        end
+                        'yes' # ma sadly will have nil when i just throw
                       end
                     elsif code.is_a?(String)
-                      mr = ManipulateStructure.new(@__weel_data,@__weel_endpoints,@__weel_status)
+                      mr = ManipulateStructure.new(@__weel_data,@__weel_endpoints,@__weel_status,handlerwrapper.additional)
                       ma = catch Signal::Again do
                         handlerwrapper.manipulate(mr,code,handlerwrapper.activity_result_value,handlerwrapper.activity_result_options)
                         'yes' # ma sadly will have nil when i just throw

data/test/TestHandlerWrapper.rb

@@ -8,16 +8,24 @@ class TestHandlerWrapper < WEEL::HandlerWrapperBase
     $short_track << "E"
     raise(err)
   end
+  def self::inform_handlerwrapper_error(arguments,err)
+    $long_track += "HW ERROR: #{err}\n"
+    $short_track << "E"
+  end
 
-  def initialize(args,endpoint=nil,position=nil,continue=nil)
+  def initialize(args,position=nil,continue=nil)
     @__myhandler_stopped = false
     @__myhandler_position = position
     @__myhandler_continue = continue
-    @__myhandler_endpoint = endpoint
     @__myhandler_returnValue = nil
     @t = nil
   end
 
+  def prepare(readonly, endpoints, parameters, replay=false)
+    @__myhandler_endpoint = readonly.endpoints[endpoints]
+    parameters
+  end
+
   # executes a ws-call to the given endpoint with the given parameters. the call
   # can be executed asynchron, see finished_call & return_value
   def activity_handle(passthrough, parameters) #{{{
@@ -68,7 +76,7 @@ class TestHandlerWrapper < WEEL::HandlerWrapperBase
   # information about how to continue the call. This passthrough-value is given
   # to activity_handle if the workflow is configured to do so.
   def activity_passthrough_value #{{{
-    "SOME passthrough"
+    nil
   end #}}}
 
   # Called if the execution of the actual activity_handle is not necessary anymore

data/test/TestMixin.rb

@@ -14,14 +14,14 @@ module SimTestMixin #{{{
   def wf_assert(what,cond=true)
     if cond
       assert($long_track.include?(what),"Missing \"#{what}\":\n#{$long_track}")
-    else  
+    else
       assert(!$long_track.include?(what),"Missing \"#{what}\":\n#{$long_track}")
     end
   end
   def wf_sassert(what,cond=true)
     if cond
       assert($short_track.include?(what),"#{$short_track}\nNot Present \"#{what}\":\n#{$long_track}")
-    else  
+    else
       assert(!$short_track.include?(what),"#{$short_track}\nNot Present \"#{what}\":\n#{$long_track}")
     end
   end
@@ -30,7 +30,6 @@ module SimTestMixin #{{{
   end
 end  #}}}
 
-
 module TestMixin #{{{
   def setup
     $long_track = ""
@@ -47,14 +46,14 @@ module TestMixin #{{{
   def wf_assert(what,cond=true)
     if cond
       assert($long_track.include?(what),"Missing \"#{what}\":\n#{$long_track}")
-    else  
+    else
       assert(!$long_track.include?(what),"Missing \"#{what}\":\n#{$long_track}")
     end
   end
   def wf_sassert(what,cond=true)
     if cond
       assert($short_track.include?(what),"#{$short_track}\nNot Present \"#{what}\":\n#{$long_track}")
-    else  
+    else
       assert(!$short_track.include?(what),"#{$short_track}\nNot Present \"#{what}\":\n#{$long_track}")
     end
   end

data/test/TestWorkflow.rb

@@ -9,12 +9,12 @@ class TestWorkflow < WEEL
   endpoint :stop => 'stop it'
   endpoint :again => 'again'
   data :x => 'begin_'
-  
+
   control flow do
     call :a1_1, :endpoint1 do |result|
       data.x += "#{result}"
     end
-    parallel :wait => 2 do
+    parallel :wait do
       parallel_branch do
         call :a2_1_1, :endpoint1
       end

data/test/basic/tc_choose.rb

@@ -24,59 +24,59 @@ class TestChoose < Test::Unit::TestCase
     wf_assert("CALL a_3:",false)
   end
 
-  def test_choose_otherwise
-    @wf.description do
-      choose do
-        alternative false do
-          call :a_1, :endpoint1
-        end
-        otherwise do
-          call :a_2, :endpoint1
-        end
-      end
-    end
-    @wf.start.join
-    wf_assert("CALL a_2: passthrough=[], endpoint=[http://www.heise.de], parameters=[{}]")
-    wf_assert("CALL a_1:",false)
-  end
+  # def test_choose_otherwise
+  #   @wf.description do
+  #     choose do
+  #       alternative false do
+  #         call :a_1, :endpoint1
+  #       end
+  #       otherwise do
+  #         call :a_2, :endpoint1
+  #       end
+  #     end
+  #   end
+  #   @wf.start.join
+  #   wf_assert("CALL a_2: passthrough=[], endpoint=[http://www.heise.de], parameters=[{}]")
+  #   wf_assert("CALL a_1:",false)
+  # end
 
-  def test_choose_nested
-    @wf.description do
-      choose do
-        alternative true do
-          choose do
-            alternative false do
-              call :a_1_1, :endpoint1
-            end
-            alternative true do
-              choose do
-                alternative false do
-                  call :a_1_1_1, :endpoint1
-                end
-                otherwise do
-                  call :a_1_1_2, :endpoint1
-                end
-              end
-            end
-            otherwise do
-              call :a_1_3, :endpoint1
-            end
-          end
-        end
-        otherwise do
-          call :a_2, :endpoint1
-        end
-      end
-    end
-    @wf.start.join
-    wf_assert("CALL a_1_1_2: passthrough=[], endpoint=[http://www.heise.de], parameters=[{}]",true)
-    wf_assert("CALL a_1_1:",false)
-    wf_assert("CALL a_1_1_1:",false)
-    wf_assert("CALL a_1_3:",false)
-    wf_assert("CALL a_2:",false)
-  end
+  # def test_choose_nested
+  #   @wf.description do
+  #     choose do
+  #       alternative true do
+  #         choose do
+  #           alternative false do
+  #             call :a_1_1, :endpoint1
+  #           end
+  #           alternative true do
+  #             choose do
+  #               alternative false do
+  #                 call :a_1_1_1, :endpoint1
+  #               end
+  #               otherwise do
+  #                 call :a_1_1_2, :endpoint1
+  #               end
+  #             end
+  #           end
+  #           otherwise do
+  #             call :a_1_3, :endpoint1
+  #           end
+  #         end
+  #       end
+  #       otherwise do
+  #         call :a_2, :endpoint1
+  #       end
+  #     end
+  #   end
+  #   @wf.start.join
+  #   wf_assert("CALL a_1_1_2: passthrough=[], endpoint=[http://www.heise.de], parameters=[{}]",true)
+  #   wf_assert("CALL a_1_1:",false)
+  #   wf_assert("CALL a_1_1_1:",false)
+  #   wf_assert("CALL a_1_3:",false)
+  #   wf_assert("CALL a_2:",false)
+  # end
 
-  def test_choose_searchmode
-    
-  end
+  # def test_choose_searchmode
+
+  # end
 end

data/test/basic/tc_state.rb

@@ -4,11 +4,11 @@ require File.expand_path(::File.dirname(__FILE__) + '/../TestWorkflow')
 class TestState < Test::Unit::TestCase
   include TestMixin
 
-  def test_check_state
-    s = @wf.state
-    assert(s.is_a?(Symbol), "state is not a symbol")
-    assert(s == :ready, "state is not set to :ready, it is #{s}")
-  end
+  # def test_check_state
+  #   s = @wf.state
+  #   assert(s.is_a?(Symbol), "state is not a symbol")
+  #   assert(s == :ready, "state is not set to :ready, it is #{s}")
+  # end
 
   def test_check_stop_state
     @wf.start

data/test/basic/tc_wf_control.rb

@@ -18,51 +18,51 @@ class TestWorkflowControl < Test::Unit::TestCase
     assert(@wf.data[:x] == "begin_Handler_Dummy_Result_end", "Ending environment not correct, see result=#{@wf.data[:x].inspect}")
   end
 
-  def test_stop
-    @wf.description do
-      call :a_test_1_1, :endpoint1
-      call :a_test_1_2, :endpoint1, parameters: { :call => Proc.new{ sleep 0.5 } }
-      call :a_test_1_3, :endpoint1
-    end
-    @wf.search WEEL::Position.new(:a_test_1_1, :at)
-    wf = @wf.start
-    sleep(0.2)
-    @wf.stop.join
-    wf.join
-    wf_assert("DONE a_test_1_1")
-    wf_assert("STOPPED a_test_1_2")
-    wf_assert("DONE a_test_1_2",false)
-    wf_assert("CALL a_test_1_2:")
-    assert(@wf.state == :stopped, "Stopped workflow has wrong state, #{@wf.state} instead of :stopped")
-    assert(@wf.positions.is_a?(Array), "@wf.positions has wrong type, should be an array, it is: #{@wf.positions.inspect}")
-    assert(@wf.positions[0].position == :a_test_1_2, "Stop-position has wrong value: #{@wf.positions[0].position} instead of :a_test_2_1")
-    assert(@wf.positions[0].detail == :at, "Stop-Position is not :at")
-  end
-  def test_continue
-    @wf.description do
-      call :a_test_1_1, :endpoint1
-      call :a_test_1_2, :endpoint1, parameters: { :call =>  Proc.new{ sleep 0.5 } }
-      call :a_test_1_3, :endpoint1
-    end
-    @wf.start
-    sleep(0.2)
-    @wf.stop.join
+  # def test_stop
+  #   @wf.description do
+  #     call :a_test_1_1, :endpoint1
+  #     call :a_test_1_2, :endpoint1, parameters: { :call => Proc.new{ sleep 0.5 } }
+  #     call :a_test_1_3, :endpoint1
+  #   end
+  #   @wf.search WEEL::Position.new(:a_test_1_1, :at)
+  #   wf = @wf.start
+  #   sleep(0.2)
+  #   @wf.stop.join
+  #   wf.join
+  #   wf_assert("DONE a_test_1_1")
+  #   wf_assert("STOPPED a_test_1_2")
+  #   wf_assert("DONE a_test_1_2",false)
+  #   wf_assert("CALL a_test_1_2:")
+  #   assert(@wf.state == :stopped, "Stopped workflow has wrong state, #{@wf.state} instead of :stopped")
+  #   assert(@wf.positions.is_a?(Array), "@wf.positions has wrong type, should be an array, it is: #{@wf.positions.inspect}")
+  #   assert(@wf.positions[0].position == :a_test_1_2, "Stop-position has wrong value: #{@wf.positions[0].position} instead of :a_test_2_1")
+  #   assert(@wf.positions[0].detail == :at, "Stop-Position is not :at")
+  # end
+  # def test_continue
+  #   @wf.description do
+  #     call :a_test_1_1, :endpoint1
+  #     call :a_test_1_2, :endpoint1, parameters: { :call =>  Proc.new{ sleep 0.5 } }
+  #     call :a_test_1_3, :endpoint1
+  #   end
+  #   @wf.start
+  #   sleep(0.2)
+  #   @wf.stop.join
 
-    @wf.search @wf.positions
+  #   @wf.search @wf.positions
 
-    @wf.start.join
-    wf_sassert('|running|Ca_test_1_1Da_test_1_1Ca_test_1_2|stopping|Sa_test_1_2|stopped||running|Ca_test_1_2Da_test_1_2Ca_test_1_3Da_test_1_3|finished|')
-  end
-  
-  def test_continue_after
-    @wf.description do
-      call :c_test_1_1, :endpoint1
-      call :c_test_1_2, :endpoint1
-      call :c_test_1_3, :endpoint1
-    end
-    @wf.search [WEEL::Position.new(:c_test_1_1, :after)]
-    @wf.start.join
+  #   @wf.start.join
+  #   wf_sassert('|running|Ca_test_1_1Da_test_1_1Ca_test_1_2|stopping|Sa_test_1_2|stopped||running|Ca_test_1_2Da_test_1_2Ca_test_1_3Da_test_1_3|finished|')
+  # end
 
-    wf_sassert('|running|Cc_test_1_2Dc_test_1_2Cc_test_1_3Dc_test_1_3|finished|')
-  end
+  # def test_continue_after
+  #   @wf.description do
+  #     call :c_test_1_1, :endpoint1
+  #     call :c_test_1_2, :endpoint1
+  #     call :c_test_1_3, :endpoint1
+  #   end
+  #   @wf.search [WEEL::Position.new(:c_test_1_1, :after)]
+  #   @wf.start.join
+
+  #   wf_sassert('|running|Cc_test_1_2Dc_test_1_2Cc_test_1_3Dc_test_1_3|finished|')
+  # end
 end

data/test/complexsearch/tc_search.rb

@@ -6,7 +6,7 @@ class TestAdventureSearch < Test::Unit::TestCase
 
   def test_search_adventure
     @wf.data[:oee] = 0.25
-    @wf.description = File.read(::File.dirname(__FILE__) + '/dsl1')
+    @wf.description = File.read(__dir__ + '/dsl1')
     @wf.search [WEEL::Position.new(:a2, :at), WEEL::Position.new(:a13, :at)]
     @wf.start.join
 

data/test/test

@@ -0,0 +1,39 @@
+ruby basic/tc_choose.rb
+ruby basic/tc_codereplace.rb
+ruby basic/tc_data.rb
+ruby basic/tc_endpoint.rb
+ruby basic/tc_handler.rb
+ruby basic/tc_parallel.rb
+ruby basic/tc_search.rb
+ruby basic/tc_state.rb
+ruby basic/tc_wf_control.rb
+ruby complexsearch/tc_search.rb
+ruby complex/tc_generalsynchonizingmerge_loopsearch.rb
+ruby complex/tc_parallel_stop.rb
+ruby exec/tc_again.rb
+ruby exec/tc_exec.rb
+ruby simulation/dl.rb
+ruby simulation/tt_permutationtester.rb
+ruby simulation/tt_sim_activity.rb
+ruby simulation/tt_sim_choose1.rb
+ruby simulation/tt_sim_choose2.rb
+ruby simulation/tt_sim_loop_parallel_choose.rb
+ruby simulation/tt_sim_loop_parallel.rb
+ruby simulation/tt_sim_loop.rb
+ruby speed/tc_speed1.rb
+ruby speed/tc_speed2.rb
+ruby wfp_adv_branching/tc_generalizedjoin.rb
+ruby wfp_adv_branching/tc_generalsynchronizingmerge.rb
+ruby wfp_adv_branching/tc_localsynchronizingmerge.rb
+ruby wfp_adv_branching/tc_multichoice_structuredsynchronizingmerge.rb
+ruby wfp_adv_branching/tc_multimerge.rb
+ruby wfp_adv_branching/tc_structured_discriminator.rb
+ruby wfp_adv_branching/tc_structured_partial_join.rb
+ruby wfp_adv_branching/tc_threadmerge.rb
+ruby wfp_adv_branching/tc_threadsplit.rb
+ruby wfp_basic/tc_exclusivechoice_simplemerge.rb
+ruby wfp_basic/tc_parallelsplit_synchronization.rb
+ruby wfp_basic/tc_sequence.rb
+ruby wfp_iteration/tc_structuredloop.rb
+ruby wfp_state_based/tc_deferredchoice.rb
+ruby wfp_state_based/tc_interleavedparallelrouting.rb

data/weel.gemspec

@@ -1,17 +1,17 @@
 Gem::Specification.new do |s|
   s.name             = "weel"
-  s.version          = "1.99.81"
+  s.version          = "1.99.83"
   s.platform         = Gem::Platform::RUBY
   s.license          = "LGPL-3.0"
-  s.summary          = "Preliminary release of the Workflow Execution Engine Library (WEEL)"
+  s.summary          = "Workflow Execution Engine Library (WEEL)"
 
   s.description      = "see http://cpee.org"
 
-  s.required_ruby_version = '>=2.3.0'
+  s.required_ruby_version = '>=2.6.0'
 
-  s.files            = Dir['{example/**/*,lib/weel.rb}'] + %w(COPYING Changelog FEATURES INSTALL Rakefile weel.gemspec README AUTHORS)
+  s.files            = Dir['{example/**/*,lib/weel.rb}'] + %w(COPYING Changelog FEATURES INSTALL Rakefile weel.gemspec README.md AUTHORS)
   s.require_path     = 'lib'
-  s.extra_rdoc_files = ['README']
+  s.extra_rdoc_files = ['README.md']
   s.test_files       = Dir['{test/*,test/*/tc_*.rb}']
 
   s.authors          = ['Juergen eTM Mangler','Gerhard Stuermer']

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: weel
 version: !ruby/object:Gem::Version
-  version: 1.99.81
+  version: 1.99.83
 platform: ruby
 authors:
 - Juergen eTM Mangler
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-27 00:00:00.000000000 Z
+date: 2020-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit
@@ -30,14 +30,14 @@ email: juergen.mangler@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files:
-- README
+- README.md
 files:
 - AUTHORS
 - COPYING
 - Changelog
 - FEATURES
 - INSTALL
-- README
+- README.md
 - Rakefile
 - example/SimpleHandlerWrapper.rb
 - example/SimpleWorkflow.rb
@@ -65,6 +65,7 @@ files:
 - test/exec/tc_exec.rb
 - test/speed/tc_speed1.rb
 - test/speed/tc_speed2.rb
+- test/test
 - test/wfp_adv_branching/tc_generalizedjoin.rb
 - test/wfp_adv_branching/tc_generalsynchronizingmerge.rb
 - test/wfp_adv_branching/tc_localsynchronizingmerge.rb
@@ -93,7 +94,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -103,9 +104,10 @@ requirements: []
 rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
-summary: Preliminary release of the Workflow Execution Engine Library (WEEL)
+summary: Workflow Execution Engine Library (WEEL)
 test_files:
 - test/TestHandlerWrapper.rb
+- test/test
 - test/ContinueTest.rb
 - test/TestWorkflow.rb
 - test/TestMixin.rb

data/README

@@ -1,4 +0,0 @@
-All code in this package is provided under the LGPL-3 license.
-Please read the file COPYING.
-
-Tested for MRI >= 1.9.3