weel 1.99.80 → 1.99.88

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd7014b809336a6c102633b2d1e46c67bf3ddf4ab7a85e2c16a45d225d397074
-  data.tar.gz: 3e40ca8e6317ccab10f4a7e17928531b851c23481376e66b6bdfb8d67cfef65a
+  metadata.gz: 26837244dc867c672c8999f93f835092edbe37c02a61d1aad43b0e9b4e9566bf
+  data.tar.gz: b929d66dc9050ad20a130412d219de79715e27b9bed2e2df9c0b67cbe4621471
 SHA512:
-  metadata.gz: d94a84ff33c81361f70185c220ccddd76bea06c61194f91c1b5767766512f4d07b938270169ca4c45dae962c3e8841f6c4b329c1d096752131747b3f826996b3
-  data.tar.gz: f7fbdf0206fb8fcec716d4254e5b8202f0a749b12c14d0da0fed3a495320097e96adbdf2b7d3e0238a6220335ecf07008c37134881d40727f121d6b1de281135
+  metadata.gz: a1e2c147083f56c6b2e1229414e118fe2387ed54cab963ae418c8e8b2142bfb7b70fced4fb1d731bc95e2093848fe79011242171c1cdcb469b3ffbe5880b3550
+  data.tar.gz: 59b6025af6e055145637abb28e988693e09c23771cf7f2747fd850dafe635db6c72f512a727320e0ff42fa4ba9218aee2ff30d9e816051a6cbb143b71eab4e01

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,48 @@ 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.include?(m)
         begin
-          Marshal.load(Marshal.dump(v))
+          tmp = Marshal.load(Marshal.dump(@additional[m]))
+          if tmp.is_a? Hash
+            ReadHash.new(tmp)
+          else
+            tmp
+          end
         rescue
-          v.to_s rescue nil
+          m.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 +92,22 @@ end # }}}
       @touched_data = []
       @changed_endpoints = []
       @touched_endpoints = []
+      @additional = additional
+    end
+
+    def method_missing(m,*args,&block)
+      if @additional.include?(m)
+        begin
+          tmp = Marshal.load(Marshal.dump(@additional[m]))
+          if tmp.is_a? Hash
+            ReadHash.new(tmp)
+          else
+            tmp
+          end
+        rescue
+          m.to_s rescue nil
+        end
+      end
     end
 
     def changed_data
@@ -209,17 +240,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
@@ -256,7 +288,7 @@ end # }}}
     end
     def as_json(*)
       jsn = { 'position' => @position }
-      jsn['passtrough'] = @passthrough if @passthrough
+      jsn['passthrough'] = @passthrough if @passthrough
       jsn
     end
     def to_s
@@ -288,7 +320,7 @@ end # }}}
      end
    end #}}}
 
-  def self::search(weel_search)# {{{
+  def self::search(*weel_search)# {{{
     define_method :initialize_search do
       self.search weel_search
     end
@@ -364,8 +396,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 +406,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 +419,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 +442,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 +468,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 +488,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 +505,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 +522,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 +533,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 +553,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 +579,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 +588,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 +654,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
@@ -635,24 +669,26 @@ end # }}}
 
     def __weel_progress(searchmode, position, skip=false) #{{{
       ipc = {}
-      if searchmode == :after
-        wp = WEEL::Position.new(position, :after, nil)
-        ipc[:after] = [wp]
-      else
-        if Thread.current[:branch_parent] && Thread.current[:branch_parent][:branch_position]
-          @__weel_positions.delete Thread.current[:branch_parent][:branch_position]
-          ipc[:unmark] ||= []
-          ipc[:unmark] << Thread.current[:branch_parent][:branch_position] rescue nil
-          Thread.current[:branch_parent][:branch_position] = nil
-        end
-        if Thread.current[:branch_position]
-          @__weel_positions.delete Thread.current[:branch_position]
-          ipc[:unmark] ||= []
-          ipc[:unmark] << Thread.current[:branch_position] rescue nil
-        end
-        wp = WEEL::Position.new(position, skip ? :after : :at, nil)
-        ipc[skip ? :after : :at] = [wp]
+      if Thread.current[:branch_parent] && Thread.current[:branch_parent][:branch_position]
+        @__weel_positions.delete Thread.current[:branch_parent][:branch_position]
+        ipc[:unmark] ||= []
+        ipc[:unmark] << Thread.current[:branch_parent][:branch_position] rescue nil
+        Thread.current[:branch_parent][:branch_position] = nil
       end
+      if Thread.current[:branch_position]
+        @__weel_positions.delete Thread.current[:branch_position]
+        ipc[:unmark] ||= []
+        ipc[:unmark] << Thread.current[:branch_position] rescue nil
+      end
+      wp = WEEL::Position.new(position, skip ? :after : :at, nil)
+      ipc[skip ? :after : :at] = [wp]
+
+      @__weel_search_positions.each do |k,ele| # some may still be in active search but lets unmark them for good measure
+        ipc[:unmark] ||= []
+        ipc[:unmark] << ele
+        true
+      end
+
       @__weel_positions << wp
       Thread.current[:branch_position] = wp
 
@@ -689,10 +725,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 +745,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 +795,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
@@ -876,7 +912,7 @@ end # }}}
           branch = branch[:branch_parent]
           branch[:branch_search] = false
         end
-        @__weel_search_positions[position].detail == :after ? :after : false
+        @__weel_search_positions[position].detail == :after
       else
         branch[:branch_search] = true
       end

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.80"
+  s.version          = "1.99.88"
   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.5.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.80
+  version: 1.99.88
 platform: ruby
 authors:
 - Juergen eTM Mangler
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-21 00:00:00.000000000 Z
+date: 2020-09-23 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,19 +94,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+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