weel 1.99.78 → 1.99.84

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ba66fd2448bc777292487140faac23d6f0fd00a264953dff4b16e302a6a9344
-  data.tar.gz: 93a76802212618b1e5fb20dd29475ee671a2d5d53bc7595655b9a8d751332765
+  metadata.gz: b5a2078e30e109e2157cbf57097fb9397ef6c70be651ecd126921e2387a25e2e
+  data.tar.gz: b71439bf1e34769f65e708cbbc81b6c7304df708c1e1ba3ced934974624b6e0c
 SHA512:
-  metadata.gz: 6a8773185c37a30e34a6f8712cd9c7ad41bd44f6a76bb99e7ab41839448846c1b8a3a4a1285700c913b6a5a2b169b4fe3e38be2e688fc3e42cd08e3dea9b41c6
-  data.tar.gz: 243c9322426d3db3ee97d9e78cf9dd5f9221dab1c7206ce49a983406acf59bcc3f6275a4d95177d4ea9aa70d440a841ad1d8ff1d052fc52849daa65ec9431a75
+  metadata.gz: 68272ea7e69825b4c1aa7e4ba7ab570d9df41f82ff40c641d87beacfedca8e5e1bd53eb6885753c3f738bec921709ebf37ed44aff0d32cd9630fdb122143c35e
+  data.tar.gz: 4cbad38225d73f475669926c7aaa1ea645bdebdc235512ecd08a8c64ad8fd91599b846e276cdce2a30deea78d184503ea8da542fe6d66cba4447c00a215c5c3c

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/example/SimpleHandlerWrapper.rb

@@ -1,13 +1,13 @@
 # This file is part of WEEL.
-# 
+#
 # WEEL is free software: you can redistribute it and/or modify it under the terms
 # of the GNU General Public License as published by the Free Software Foundation,
 # either version 3 of the License, or (at your option) any later version.
-# 
+#
 # WEEL is distributed in the hope that it will be useful, but WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 # PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU General Public License along with
 # WEEL (file COPYING in the main directory).  If not, see
 # <http://www.gnu.org/licenses/>.
@@ -15,14 +15,23 @@
 require "pp"
 
 class SimpleHandlerWrapper < WEEL::HandlerWrapperBase
-  def initialize(args,endpoint=nil,position=nil,continue=nil)
+  def self::inform_state_change(arguments,newstate); puts "#{newstate}: #{arguments}"; end
+  def self::inform_syntax_error(arguments,err,code); puts "Syntax error: #{err}"; end
+  def self::inform_handlerwrapper_error(arguments,err); puts "Handlerwrapper error: #{err}"; end
+
+  def initialize(args,position=nil,continue=nil)
     @__myhandler_stopped = false
     @__myhandler_position = position
     @__myhandler_continue = continue
-    @__myhandler_endpoint = endpoint
+    @__myhandler_endpoint = nil
     @__myhandler_returnValue = nil
   end
 
+  def prepare(readonly, endpoints, parameters, replay=false)
+    @__myhandler_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)
@@ -35,7 +44,7 @@ class SimpleHandlerWrapper < WEEL::HandlerWrapperBase
     @__myhandler_returnValue = 'Handler_Dummy_Result'
     @__myhandler_continue.continue
   end
- 
+
   # returns the result of the last handled call
   def activity_result_value
     @__myhandler_returnValue

data/example/SimpleWorkflow.rb

@@ -1,13 +1,13 @@
 # This file is part of WEEL.
-# 
+#
 # WEEL is free software: you can redistribute it and/or modify it under the terms
 # of the GNU General Public License as published by the Free Software Foundation,
 # either version 3 of the License, or (at your option) any later version.
-# 
+#
 # WEEL is distributed in the hope that it will be useful, but WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 # PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU General Public License along with
 # WEEL (file COPYING in the main directory).  If not, see
 # <http://www.gnu.org/licenses/>.
@@ -17,12 +17,12 @@ require ::File.dirname(__FILE__) + '/SimpleHandlerWrapper'
 
 class SimpleWorkflow < WEEL
   handlerwrapper SimpleHandlerWrapper
-  
+
   endpoint :ep1 => "orf.at"
   data :a => 17
 
   control flow do
-    activity :a1, :call, :ep1, :a => data.a, :b => 2 do
+    call :a1, :ep1, parameters: { :a => data.a, :b => 2 } do
       data.a += 3
     end
   end

data/example/runme.rb

@@ -1,14 +1,14 @@
 #!/usr/bin/env ruby
 # This file is part of WEEL.
-# 
+#
 # WEEL is free software: you can redistribute it and/or modify it under the terms
 # of the GNU General Public License as published by the Free Software Foundation,
 # either version 3 of the License, or (at your option) any later version.
-# 
+#
 # WEEL is distributed in the hope that it will be useful, but WITHOUT ANY
 # WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 # PARTICULAR PURPOSE.  See the GNU General Public License for more details.
-# 
+#
 # You should have received a copy of the GNU General Public License along with
 # WEEL (file COPYING in the main directory).  If not, see
 # <http://www.gnu.org/licenses/>.

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 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); parameters; 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
@@ -288,7 +310,7 @@ end # }}}
      end
    end #}}}
 
-  def self::search(weel_search)# {{{
+  def self::search(*weel_search)# {{{
     define_method :initialize_search do
       self.search weel_search
     end
@@ -338,9 +360,10 @@ end # }}}
       @__weel_handlerwrapper_args = []
       @__weel_state = :ready
       @__weel_status = Status.new(0,"undefined")
+      @__weel_replay = false
       @__weel_sim = -1
     end #}}}
-    attr_accessor :__weel_search_positions, :__weel_positions, :__weel_main, :__weel_data, :__weel_endpoints, :__weel_handlerwrapper, :__weel_handlerwrapper_args
+    attr_accessor :__weel_search_positions, :__weel_positions, :__weel_main, :__weel_data, :__weel_endpoints, :__weel_handlerwrapper, :__weel_handlerwrapper_args, :__weel_replay
     attr_reader :__weel_state, :__weel_status
 
     # DSL-Constructs for atomic calls to external services (calls) and pure context manipulations (manipulate).
@@ -363,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
@@ -373,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
@@ -386,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
 
@@ -409,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
 
@@ -435,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
 
@@ -453,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
@@ -470,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
@@ -487,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
@@ -498,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
@@ -518,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
@@ -544,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
@@ -553,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
@@ -619,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
@@ -688,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(
@@ -708,15 +733,15 @@ 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
                 end
-                params = handlerwrapper.prepare(rs,endpoint,parameters)
+                params = handlerwrapper.prepare(rs,endpoint,parameters,@__weel_replay)
                 raise Signal::Stop unless handlerwrapper.vote_sync_before(params)
                 raise Signal::Skip if self.__weel_state == :stopping || self.__weel_state == :finishing
 
@@ -726,7 +751,6 @@ end # }}}
                 else
                   passthrough = nil
                 end
-
                 handlerwrapper.activity_handle passthrough, params
                 wp.passthrough = handlerwrapper.activity_passthrough_value
                 unless wp.passthrough.nil?
@@ -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
@@ -814,7 +838,7 @@ end # }}}
         handlerwrapper.inform_activity_failed se
         self.__weel_state = :stopping
       rescue => err
-        handlerwrapper.inform_activity_failed err
+        @__weel_handlerwrapper::inform_handlerwrapper_error @__weel_handlerwrapper_args, err
         self.__weel_state = :stopping
       ensure
         Thread.current[:continue].clear if Thread.current[:continue] && Thread.current[:continue].is_a?(Continue)
@@ -915,6 +939,7 @@ end # }}}
       if newState == :stopping || newState == :finishing
         @__weel_status.nudge!
         __weel_recursive_continue(@__weel_main)
+        __weel_replay = false
       end
 
       @__weel_handlerwrapper::inform_state_change @__weel_handlerwrapper_args, @__weel_state
@@ -1067,6 +1092,11 @@ public
     end
   end # }}}
 
+  def replay
+    @dslr.__weel_replay = true
+    start
+  end
+
   def sim # {{{
     stat = @dslr.__weel_state
     return nil unless stat == :ready || stat == :stopped

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.78"
+  s.version          = "1.99.84"
   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.78
+  version: 1.99.84
 platform: ruby
 authors:
 - Juergen eTM Mangler
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-15 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,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