weel 1.99.121 → 1.99.123

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3dc94f3d9dc7b182dc017f529211878cdbffa2504d1f863220d0820b786e28b
-  data.tar.gz: 816645f85946983a86ba373e4e5e660b2688fc32c57e0f72e44a4d71a774b9b0
+  metadata.gz: f3b3b0d940b57bff46c012f46466be8cbd1188de768e10cc8815f597d0ec2045
+  data.tar.gz: 7cceda505453b4610f79c01d3b38a55d99cf861119d00059b744f2e53ce6be6b
 SHA512:
-  metadata.gz: a22047ce8e533de6326a7cccbdb25a7dfabc5b137880b111ff2032cdb1d32bd45f0f3fccb421e72f4d823a8d84a6fd3ec67d81ee3e1bef0b61c755621e28bee2
-  data.tar.gz: 5ebc7c1d4a819a23ee2399be8818f80b7de71fb6753351750d3dbabe2ad122f6be6fe783f30d3d5acd00e1ff927c57f90b0c5052b8195d889420b217625cf37d
+  metadata.gz: d9691c2f36e38b8552f6c22cd774c7d7920adb9511f5fd9e9838ba9b5f03f00624dfc461d97a2551a76ea3f5c4732e7d70ae6c7ef84a8b9c0ce95992c617f153
+  data.tar.gz: 0565f1fd91b28309fe38343332a423aff7d6f123387f671616fc320cb6dae9edd91051a43bbaf0241e791ef3efd6ae2377c254d2fa1ff40069327bd3f517ec4c

data/lib/weel.rb

@@ -38,6 +38,7 @@ class WEEL
     class Proceed < Exception; end
     class NoLongerNecessary < Exception; end
     class Again < Exception; end
+    class UpdateAgain < Exception; end
     class Error < Exception; end
     class Salvage < Exception; end
   end # }}}
@@ -104,8 +105,9 @@ class WEEL
       ReadHash.new(@__weel_endpoints)
     end
     def local
-      @__weel_local.first
+      @__weel_local&.first
     end
+    attr_reader :additional
   end # }}}
   class ManipulateStructure # {{{
     def initialize(data,endpoints,status,local,additional)
@@ -194,11 +196,12 @@ class WEEL
       ManipulateHash.new(@__weel_endpoints,@touched_endpoints,@changed_endpoints)
     end
     def local
-      @__weel_local.first
+      @__weel_local&.first
     end
     def status
       @__weel_status
     end
+    attr_reader :additional
   end # }}}
   class ManipulateHash # {{{
     attr_reader :__weel_touched, :__weel_changed
@@ -269,9 +272,8 @@ class WEEL
   end #}}}
 
   class ReadHash # {{{
-    def initialize(values,sim=false)
+    def initialize(values)
       @__weel_values = values
-      @__weel_sim = sim
     end
 
     def to_json(*args)
@@ -279,29 +281,25 @@ class WEEL
     end
 
     def method_missing(name,*args)
-      if @__weel_sim
-        "➤#{name}"
+      if args.empty? && @__weel_values.key?(name)
+        @__weel_values[name]
+      elsif args.empty? && @__weel_values.key?(name.to_s)
+        @__weel_values[name.to_s]
+      elsif name.to_s[-1..-1] == "=" && args.length == 1
+        temp = name.to_s[0..-2]
+        @__weel_values[temp.to_sym] = args[0]
+      elsif name.to_s == "[]=" && args.length == 2
+        @__weel_values[args[0]] = args[1]
+      elsif name.to_s == "[]" && args.length == 1
+        @__weel_values[args[0]]
       else
-        if args.empty? && @__weel_values.key?(name)
-          @__weel_values[name]
-        elsif args.empty? && @__weel_values.key?(name.to_s)
-          @__weel_values[name.to_s]
-        elsif name.to_s[-1..-1] == "=" && args.length == 1
-          temp = name.to_s[0..-2]
-          @__weel_values[temp.to_sym] = args[0]
-        elsif name.to_s == "[]=" && args.length == 2
-          @__weel_values[args[0]] = args[1]
-        elsif name.to_s == "[]" && args.length == 1
-          @__weel_values[args[0]]
-        else
-          nil
-        end
+        nil
       end
     end
   end # }}}
 
   class ReadOnlyHash # {{{
-    def initialize(values,sim=false)
+    def initialize(values)
       @__weel_values = values.transform_values do |v|
         if Object.const_defined?(:XML) && XML.const_defined?(:Smart) && v.is_a?(XML::Smart::Dom)
           v.root.to_doc
@@ -313,7 +311,6 @@ class WEEL
           end
         end
       end
-      @__weel_sim = sim
     end
 
     def to_json(*args)
@@ -321,27 +318,30 @@ class WEEL
     end
 
     def method_missing(name,*args)
-      if @__weel_sim
-        "➤#{name}"
+      if args.empty? && @__weel_values.key?(name)
+        @__weel_values[name]
+      elsif args.empty? && @__weel_values.key?(name.to_s)
+        @__weel_values[name.to_s]
+      elsif name.to_s[-1..-1] == "=" && args.length == 1
+        temp = name.to_s[0..-2]
+        @__weel_values[temp.to_sym] = args[0]
+      elsif name.to_s == "[]=" && args.length == 2
+        @__weel_values[args[0]] = args[1]
+      elsif name.to_s == "[]" && args.length == 1
+        @__weel_values[args[0]]
       else
-        if args.empty? && @__weel_values.key?(name)
-          @__weel_values[name]
-        elsif args.empty? && @__weel_values.key?(name.to_s)
-          @__weel_values[name.to_s]
-        elsif name.to_s[-1..-1] == "=" && args.length == 1
-          temp = name.to_s[0..-2]
-          @__weel_values[temp.to_sym] = args[0]
-        elsif name.to_s == "[]=" && args.length == 2
-          @__weel_values[args[0]] = args[1]
-        elsif name.to_s == "[]" && args.length == 1
-          @__weel_values[args[0]]
-        else
-          nil
-        end
+        nil
       end
     end
   end # }}}
 
+  class ProcString #{{{
+    attr_reader :code
+    def initialize(code)
+      @code = code
+    end
+  end #}}}
+
   class ConnectionWrapperBase # {{{
     def self::loop_guard(arguments,lid,count); false; end
     def self::inform_state_change(arguments,newstate); end
@@ -351,7 +351,6 @@ class WEEL
 
     def initialize(arguments,position=nil,continue=nil); end
 
-    def prepare(readonly, endpoints, parameters); parameters; end
     def additional; {}; end
 
     def activity_handle(passthrough, parameters); end
@@ -374,17 +373,11 @@ class WEEL
     def vote_sync_before(parameters=nil); true; end
     def vote_sync_after; true; end
 
-    # type       => activity, loop, parallel, choice
-    # nesting    => none, start, end
-    # eid        => id's also for control structures
-    # parameters => stuff given to the control structure
-    def simulate(type,nesting,sequence,parent,parameters={}); end
-
     def callback(result=nil,options={}); end
     def mem_guard; end
 
+    def prepare(readonly, endpoints, parameters); parameters; end
     def test_condition(dataelements,endpoints,local,additional,code,args={}); ReadStructure.new(dataelements,endpoints,local,additional).instance_eval(code); end
-    def eval_expression(dataelements,endpoints,local,additional,code); ReadStructure.new(dataelements,endpoints,local,additional).instance_eval(code); end
     def manipulate(readonly,lock,dataelements,endpoints,status,local,additional,code,where,result=nil,options=nil)
       lock.synchronize do
         if readonly
@@ -396,6 +389,7 @@ class WEEL
     end
 
     def join_branches(branches); end
+    def split_branches(branches); end
   end  # }}}
 
   class Position # {{{
@@ -499,14 +493,14 @@ class WEEL
       @__weel_connectionwrapper_args = []
       @__weel_state = :ready
       @__weel_status = Status.new(0,"undefined")
-      @__weel_sim = -1
+      @__weel_sim = false
       @__weel_lock = Mutex.new
     end #}}}
     attr_accessor :__weel_search_positions, :__weel_positions, :__weel_main, :__weel_data, :__weel_endpoints, :__weel_connectionwrapper, :__weel_connectionwrapper_args
     attr_reader :__weel_state, :__weel_status, :__weel_status
 
     # DSL-Construct for translating expressions into static parameters
-    def 🠊(code); __weel_eval_expression(code); end
+    def 🠊(code); ProcString.new(code); end
 
     # DSL-Constructs for atomic calls to external services (calls) and pure context manipulations (manipulate).
     # Calls can also manipulate context (after the invoking the external services)
@@ -538,8 +532,6 @@ class WEEL
       Thread.current[:branch_event] = Continue.new
       Thread.current[:mutex] = Mutex.new
 
-      hw, pos = __weel_sim_start(:parallel) if __weel_sim
-
       __weel_protect_yield(&block)
 
       Thread.current[:branch_wait_count] = (type.is_a?(Hash) && type[:wait] != nil && (type[:wait].is_a?(Integer) && type[:wait] > 0) ? type[:wait] : Thread.current[:branches].size)
@@ -549,6 +541,9 @@ class WEEL
         Thread.current[:branch_event].wait
       end
 
+      cw = @__weel_connectionwrapper.new @__weel_connectionwrapper_args
+      cw.split_branches(Thread.current[:branch_traces])
+
       Thread.current[:branches].each do |thread|
         # decide after executing block in parallel cause for coopis
         # it goes out of search mode while dynamically counting branches
@@ -560,10 +555,6 @@ class WEEL
 
       Thread.current[:branch_event].wait unless self.__weel_state == :stopping || self.__weel_state == :finishing || self.__weel_state == :stopped || Thread.current[:branches].length == 0
 
-      __weel_sim_stop(:parallel,hw,pos) if __weel_sim
-
-      cw = @__weel_connectionwrapper.new @__weel_connectionwrapper_args
-
       cw.join_branches(Thread.current[:branch_traces])
 
       unless self.__weel_state == :stopping || self.__weel_state == :finishing || self.__weel_state == :stopped
@@ -584,11 +575,6 @@ class WEEL
       return if self.__weel_state == :stopping || self.__weel_state == :finishing || self.__weel_state == :stopped || Thread.current[:nolongernecessary]
       branch_parent = Thread.current
 
-      if __weel_sim
-        # catch the potential execution in loops inside a parallel
-        current_branch_sim_pos = branch_parent[:branch_sim_pos]
-      end
-
       branch_parent[:branches] << Thread.new(*vars) do |*local|
         Thread.current.abort_on_exception = true
         Thread.current[:branch_search] = @__weel_search_positions.any?
@@ -601,10 +587,6 @@ class WEEL
           branch_parent[:branch_traces_ids] += 1
         end
 
-        if __weel_sim
-          Thread.current[:branch_sim_pos] = @__weel_sim += 1
-        end
-
         # parallel_branch could be possibly around an alternative. Thus thread has to inherit the alternative_executed
         # after branching, update it in the parent (TODO)
         if branch_parent[:alternative_executed] && branch_parent[:alternative_executed].length > 0
@@ -614,17 +596,10 @@ class WEEL
         branch_parent[:branch_event].continue
         Thread.current[:start_event].wait unless self.__weel_state == :stopping || self.__weel_state == :stopped || self.__weel_state == :finishing
 
-        if __weel_sim
-          connectionwrapper = @__weel_connectionwrapper.new @__weel_connectionwrapper_args
-          connectionwrapper.simulate(:parallel_branch,:start,Thread.current[:branch_sim_pos],current_branch_sim_pos)
-        end
-
         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,connectionwrapper,current_branch_sim_pos) if __weel_sim
-
         branch_parent[:mutex].synchronize do
           branch_parent[:branch_finished_count] += 1
 
@@ -666,9 +641,11 @@ class WEEL
       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
+
+      cw = @__weel_connectionwrapper.new @__weel_connectionwrapper_args
+      cw.split_branches(Thread.current[:branch_traces])
+
       __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
       nil
@@ -679,25 +656,21 @@ class WEEL
     # searchmode is active (to find the starting position)
     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 : nil))) if __weel_sim
       Thread.current[:mutex] ||= Mutex.new
       Thread.current[:mutex].synchronize do
         return if Thread.current[:alternative_mode][-1] == :exclusive && Thread.current[:alternative_executed][-1] == true
-        if condition.is_a?(String) && !__weel_sim
+        if condition.is_a?(String)
           condition = __weel_eval_condition(condition, args)
         end
         Thread.current[:alternative_executed][-1] = true if condition
       end
       searchmode = __weel_is_in_search_mode
-      __weel_protect_yield(&block) if searchmode || __weel_sim || condition
+      __weel_protect_yield(&block) if searchmode || condition
       Thread.current[:alternative_executed][-1] = true if __weel_is_in_search_mode != searchmode # we swiched from searchmode true to false, thus branch has been executed which is as good as evaling the condition to true
-      __weel_sim_stop(:alternative,hw,pos,args.merge(:mode => Thread.current[:alternative_mode].last, :condition => (condition.is_a?(String) ? condition : nil))) if __weel_sim
     end # }}}
     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(&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
+      __weel_protect_yield(&block) if __weel_is_in_search_mode || !Thread.current[:alternative_executed].last
     end # }}}
 
     # Defines a critical block (=Mutex)
@@ -733,15 +706,6 @@ class WEEL
           condition[1] = :pre_test
         end
       end
-      if __weel_sim
-        cond = condition[0]
-        hw, pos = __weel_sim_start(:loop,args.merge(:testing=>condition[1],:condition=>cond))
-        catch :escape do
-          __weel_protect_yield(&block)
-        end
-        __weel_sim_stop(:loop,hw,pos,args.merge(:testing=>condition[1],:condition=>cond))
-        return
-      end
       loop_guard = 0
       loop_id = SecureRandom.uuid
       catch :escape do
@@ -802,7 +766,7 @@ class WEEL
       @__weel_status
     end # }}}
     def data # {{{
-      ReadOnlyHash.new(@__weel_data,__weel_sim)
+      ReadOnlyHash.new(@__weel_data)
     end # }}}
     def endpoints # {{{
       ReadHash.new(@__weel_endpoints)
@@ -839,22 +803,6 @@ class WEEL
       end
     end #}}}
 
-    def __weel_eval_expression(expression) #{{{
-      begin
-        connectionwrapper = @__weel_connectionwrapper.new @__weel_connectionwrapper_args
-        connectionwrapper.eval_expression(@__weel_data,@__weel_endpoints,Thread.current[:local],connectionwrapper.additional,expression)
-      rescue NameError => err # don't look into it, or it will explode
-        # if you access $! here, BOOOM
-        self.__weel_state = :stopping
-        @__weel_connectionwrapper::inform_syntax_error(@__weel_connectionwrapper_args,Exception.new("eval_expression: `#{err.name}` is not a thing that can be used. Maybe it is meant to be a string and you forgot quotes?"),nil)
-        nil
-      rescue => err
-        self.__weel_state = :stopping
-        @__weel_connectionwrapper::inform_syntax_error(@__weel_connectionwrapper_args,Exception.new(err.message),nil)
-        nil
-      end
-    end #}}}
-
     def __weel_progress(position, uuid, skip=false) #{{{
       ipc = {}
       branch = Thread.current
@@ -902,11 +850,6 @@ class WEEL
         Thread.current[:continue] = Continue.new
         connectionwrapper = @__weel_connectionwrapper.new @__weel_connectionwrapper_args, position, Thread.current[:continue]
 
-        if __weel_sim
-          connectionwrapper.simulate(:activity,:none,@__weel_sim += 1,Thread.current[:branch_sim_pos],:position => position,:parameters => parameters,:endpoint => endpoint,:type => type,:finalize => finalize.is_a?(String) ? finalize : nil)
-          return
-        end
-
         # gather traces in threads to point to join
         if Thread.current[:branch_parent] && Thread.current[:branch_traces_id]
           Thread.current[:branch_parent][:branch_traces][Thread.current[:branch_traces_id]] ||= []
@@ -936,81 +879,78 @@ class WEEL
               @__weel_connectionwrapper::inform_position_change @__weel_connectionwrapper_args, :after => [wp]
             end
           when :call
-            begin
-              again = catch Signal::Again do
-                connectionwrapper.mem_guard
-                struct = if prepare
-                  connectionwrapper.manipulate(true,@__weel_lock,@__weel_data,@__weel_endpoints,@__weel_status,Thread.current[:local],connectionwrapper.additional,prepare,'Activity ' + position.to_s)
-                else
-                  # just the read structure, no code exec necessary
-                  ReadStructure.new(@__weel_data,@__weel_endpoints,Thread.current[:local],connectionwrapper.additional)
-                end
-                params = connectionwrapper.prepare(struct,endpoint,parameters)
-                raise Signal::Stop unless connectionwrapper.vote_sync_before(params)
-                raise Signal::Skip if self.__weel_state == :stopping || self.__weel_state == :finishing
-
-                connectionwrapper.activity_handle wp.passthrough, params
-                wp.passthrough = connectionwrapper.activity_passthrough_value
-                unless wp.passthrough.nil?
-                  @__weel_connectionwrapper::inform_position_change @__weel_connectionwrapper_args, :wait => [wp]
-                end
-                begin
-                  # cleanup after callback updates
-                  connectionwrapper.mem_guard
+            again = catch Signal::Again do
+              connectionwrapper.mem_guard
+              struct = if prepare
+                connectionwrapper.manipulate(true,@__weel_lock,@__weel_data,@__weel_endpoints,@__weel_status,Thread.current[:local],connectionwrapper.additional,prepare,'Activity ' + position.to_s)
+              else
+                # just the read structure, no code exec necessary
+                ReadStructure.new(@__weel_data,@__weel_endpoints,Thread.current[:local],connectionwrapper.additional)
+              end
+              params = connectionwrapper.prepare(struct,endpoint,parameters)
 
-                  # with loop if catching Signal::Again
-                  # handshake call and wait until it finished
-                  waitingresult = nil
-                  waitingresult = Thread.current[:continue].wait unless Thread.current[:nolongernecessary] || self.__weel_state == :stopping || self.__weel_state == :finishing || self.__weel_state == :stopped
+              raise Signal::Stop unless connectionwrapper.vote_sync_before(params)
+              raise Signal::Skip if self.__weel_state == :stopping || self.__weel_state == :finishing
 
-                  raise waitingresult[1] if !waitingresult.nil? && waitingresult.is_a?(Array) && waitingresult.length == 2 && waitingresult[0] == WEEL::Signal::Error
+              connectionwrapper.activity_handle wp.passthrough, params
+              wp.passthrough = connectionwrapper.activity_passthrough_value
+              unless wp.passthrough.nil?
+                @__weel_connectionwrapper::inform_position_change @__weel_connectionwrapper_args, :wait => [wp]
+              end
+              begin
+                # cleanup after callback updates
+                connectionwrapper.mem_guard
 
-                  if Thread.current[:nolongernecessary]
-                    connectionwrapper.activity_no_longer_necessary
-                    raise Signal::NoLongerNecessary
-                  end
-                  if self.__weel_state == :stopping || self.__weel_state == :finishing
-                    connectionwrapper.activity_stop
-                    wp.passthrough = connectionwrapper.activity_passthrough_value
-                    raise Signal::Proceed if wp.passthrough # if stop, but no passthrough, let manipulate happen and then stop
-                  end
+                # with loop if catching Signal::Again
+                # handshake call and wait until it finished
+                waitingresult = nil
+                waitingresult = Thread.current[:continue].wait unless Thread.current[:nolongernecessary] || self.__weel_state == :stopping || self.__weel_state == :finishing || self.__weel_state == :stopped
+
+                if Thread.current[:nolongernecessary]
+                  connectionwrapper.activity_no_longer_necessary
+                  raise Signal::NoLongerNecessary
+                end
+                if self.__weel_state == :stopping || self.__weel_state == :finishing
+                  connectionwrapper.activity_stop
+                  wp.passthrough = connectionwrapper.activity_passthrough_value
+                  raise Signal::Proceed if wp.passthrough # if stop, but no passthrough, let manipulate happen and then stop
+                end
 
-                  next if waitingresult == WEEL::Signal::Again && connectionwrapper.activity_result_value&.length == 0
+                next if waitingresult == WEEL::Signal::UpdateAgain && connectionwrapper.activity_result_value&.length == 0
 
-                  code = if waitingresult == WEEL::Signal::Again
-                    update
-                  elsif waitingresult == WEEL::Signal::Salvage
-                    salvage || raise('HTTP Error. The service return status was not between 200 and 300.')
-                  else
-                    finalize
-                  end
-                  if code.is_a?(String)
-                    connectionwrapper.inform_activity_manipulate
-                    struct = nil
-
-                    # when you throw without parameters, ma contains nil, so we return Signal::Proceed to give ma a meaningful value in other cases
-                    ma = catch Signal::Again do
-                      struct = connectionwrapper.manipulate(false,@__weel_lock,@__weel_data,@__weel_endpoints,@__weel_status,Thread.current[:local],connectionwrapper.additional,code,'Activity ' + position.to_s,connectionwrapper.activity_result_value,connectionwrapper.activity_result_options)
-                      Signal::Proceed
-                    end
-                    connectionwrapper.inform_manipulate_change(
-                      ((struct && struct.changed_status) ? @__weel_status : nil),
-                      ((struct && struct.changed_data.any?) ? struct.changed_data.uniq : nil),
-                      ((struct && struct.changed_endpoints.any?) ? struct.changed_endpoints.uniq : nil),
-                      @__weel_data,
-                      @__weel_endpoints
-                    )
-                    throw(Signal::Again, Signal::Again) if ma.nil?
+                code = if waitingresult == WEEL::Signal::UpdateAgain
+                  update
+                elsif waitingresult == WEEL::Signal::Salvage
+                  salvage || raise('HTTP Error. The service return status was not between 200 and 300.')
+                else
+                  finalize
+                end
+                if code.is_a?(String)
+                  connectionwrapper.inform_activity_manipulate
+                  struct = nil
+
+                  # when you throw without parameters, ma contains nil, so we return Signal::Proceed to give ma a meaningful value in other cases
+                  ma = catch Signal::Again do
+                    struct = connectionwrapper.manipulate(false,@__weel_lock,@__weel_data,@__weel_endpoints,@__weel_status,Thread.current[:local],connectionwrapper.additional,code,'Activity ' + position.to_s,connectionwrapper.activity_result_value,connectionwrapper.activity_result_options)
+                    Signal::Proceed
                   end
-                end while waitingresult == Signal::Again
-                if connectionwrapper.activity_passthrough_value.nil?
-                  connectionwrapper.inform_activity_done
-                  wp.passthrough = nil
-                  wp.detail = :after
-                  @__weel_connectionwrapper::inform_position_change @__weel_connectionwrapper_args, :after => [wp]
+                  connectionwrapper.inform_manipulate_change(
+                    ((struct && struct.changed_status) ? @__weel_status : nil),
+                    ((struct && struct.changed_data.any?) ? struct.changed_data.uniq : nil),
+                    ((struct && struct.changed_endpoints.any?) ? struct.changed_endpoints.uniq : nil),
+                    @__weel_data,
+                    @__weel_endpoints
+                  )
+                  throw(Signal::Again, Signal::Again) if ma.nil? || ma == Signal::Again # this signal again loops "there is a catch" because rescue signal throw that throughly restarts the task
                 end
+              end while waitingresult == Signal::UpdateAgain # this signal again loops because async update, proposal: rename to UpdateAgain
+              if connectionwrapper.activity_passthrough_value.nil?
+                connectionwrapper.inform_activity_done
+                wp.passthrough = nil
+                wp.detail = :after
+                @__weel_connectionwrapper::inform_position_change @__weel_connectionwrapper_args, :after => [wp]
               end
-            end while again == Signal::Again
+            end # there is a catch
         end
         raise Signal::Proceed
       rescue Signal::SkipManipulate, Signal::Proceed
@@ -1122,23 +1062,6 @@ class WEEL
       end
     end # }}}
 
-    def __weel_sim #{{{
-      @__weel_state == :simulating
-    end #}}}
-
-    def __weel_sim_start(what,options={}) #{{{
-      current_branch_sim_pos = Thread.current[:branch_sim_pos]
-      Thread.current[:branch_sim_pos] = @__weel_sim += 1
-      connectionwrapper = @__weel_connectionwrapper.new @__weel_connectionwrapper_args
-      connectionwrapper.simulate(what,:start,Thread.current[:branch_sim_pos],current_branch_sim_pos,options)
-      [connectionwrapper, current_branch_sim_pos]
-    end #}}}
-
-    def __weel_sim_stop(what,connectionwrapper,current_branch_sim_pos,options={}) #{{{
-      connectionwrapper.simulate(what,:end,Thread.current[:branch_sim_pos],current_branch_sim_pos,options)
-      Thread.current[:branch_sim_pos] = current_branch_sim_pos
-    end #}}}
-
   public
     def __weel_finalize #{{{
       __weel_recursive_join(@__weel_main)

data/weel.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name             = "weel"
-  s.version          = "1.99.121"
+  s.version          = "1.99.123"
   s.platform         = Gem::Platform::RUBY
   s.license          = "LGPL-3.0-or-later"
   s.summary          = "Workflow Execution Engine Library (WEEL)"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: weel
 version: !ruby/object:Gem::Version
-  version: 1.99.121
+  version: 1.99.123
 platform: ruby
 authors:
 - Juergen eTM Mangler
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-13 00:00:00.000000000 Z
+date: 2024-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit