weel 1.2.6 → 1.99.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 498fe6c4aea9417706e1fae8604ebd83487badb7
-  data.tar.gz: a04cc4c473ab811e5dad4c2cf25190f0cd2d8410
+  metadata.gz: 759696de1b4d59e435dbb6de3607281a78ae68b9
+  data.tar.gz: 56d4d1b419f47d5d5266c15b6f11ee907f8f3693
 SHA512:
-  metadata.gz: 51923871cbb6ddfeacf71dc30e819d1a3229148e91a1840fa30378c6ac3e02725ce5472c30f13b6999aa40cbd59e3653bd25c6641fad9511fb3c7f608a39b4ce
-  data.tar.gz: a1749f5b4d98d23d23967c152c0834ad9c88762a9c12069665a0ebd1853808ac80e26c6df4a08c8a7d109dfbc34bba23f8555a324991530dbaaf389b97e16ac3
+  metadata.gz: 2ffd15f62145efb88c1c99b23241681b6ea0ee0ecb390260b44e480c47fe9d0725fcb66813e31b29a3c9dbfef734a4c10658fd1cf8f14d9b6cfc2c2e5253f521
+  data.tar.gz: 19789e82488739d93b2eb4b250afc900260ffe03901d575a30d378a4659ddf2b316975b3fb2a57a9e2a6978f7424225c037df04ce538ee11e427d4529eb8b876

data/lib/weel.rb

@@ -71,7 +71,22 @@ class WEEL
     class NoLongerNecessary < Exception; end
   end # }}}
 
-  class ManipulateRealization # {{{
+  class ReadStructure # {{{
+    def initialize(data,endpoints)
+      @__weel_data = data
+      @__weel_endpoints = endpoints
+      @changed_data = []
+      @changed_endpoints = []
+    end
+
+    def data
+      ReadHash.new(@__weel_data)
+    end
+    def endpoints
+      ReadHash.new(@__weel_endpoints)
+    end
+  end # }}}
+  class ManipulateStructure # {{{
     def initialize(data,endpoints,status)
       @__weel_data = data
       @__weel_endpoints = endpoints
@@ -116,7 +131,6 @@ class WEEL
     end
 
     def method_missing(name,*args)
-      
       if args.empty? && @__weel_values.has_key?(name)
         @__weel_values[name] 
       elsif name.to_s[-1..-1] == "=" && args.length == 1
@@ -164,7 +178,7 @@ class WEEL
   class HandlerWrapperBase # {{{
     def initialize(arguments,endpoint=nil,position=nil,continue=nil); end
 
-    def activity_handle(passthrough, endpoint, parameters); end
+    def activity_handle(passthrough, parameters); end
 
     def activity_result_value; end
     def activity_result_status; end
@@ -183,7 +197,7 @@ class WEEL
     def inform_position_change(ipc); end
     def inform_state_change(newstate); end
     
-    def vote_sync_before; true; end
+    def vote_sync_before(parameters=nil); true; end
     def vote_sync_after; true; end
 
     # type       => activity, loop, parallel, choice
@@ -193,6 +207,9 @@ class WEEL
     def simulate(type,nesting,eid,parent,parameters={}); end
 
     def callback(result); end
+
+    def test_condition(code); true; end
+    def manipulate(mr,code,result=nil,status=nil); nil; end
   end  # }}}
 
   class Position # {{{
@@ -277,148 +294,17 @@ class WEEL
     attr_accessor :__weel_search_positions, :__weel_positions, :__weel_main, :__weel_data, :__weel_endpoints, :__weel_handlerwrapper, :__weel_handlerwrapper_args
     attr_reader :__weel_state, :__weel_status
 
-    # DSL-Construct for an atomic activity
-    # position: a unique identifier within the wf-description (may be used by the search to identify a starting point
-    # type:
-    #   - :manipulate - just yield a given block
-    #   - :call - order the handlerwrapper to perform a service call
+    # 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)
+    # position: a unique identifier within the wf-description (may be used by the search to identify a starting point)
     # endpoint: (only with :call) ep of the service
     # parameters: (only with :call) service parameters
-    def activity(position, type, endpoint=nil, *parameters, &blk)# {{{
-      position = __weel_position_test position
-      begin
-        searchmode = __weel_is_in_search_mode(position)
-        return if searchmode == true
-        return if self.__weel_state == :stopping || self.__weel_state == :stopped || Thread.current[:nolongernecessary]
-
-        Thread.current[:continue] = Continue.new
-        handlerwrapper = @__weel_handlerwrapper.new @__weel_handlerwrapper_args, @__weel_endpoints[endpoint], position, Thread.current[:continue]
-
-        if __weel_sim
-          handlerwrapper.simulate(:activity,:none,position,Thread.current[:branch_sim_pos],:parameters=>parameters, :endpoint => endpoint, :type => type)
-          return
-        end
-
-        ipc = {}
-        if searchmode == :after
-          wp = WEEL::Position.new(position, :after, nil)
-          ipc[:after] = [wp.position]
-        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].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].position rescue nil
-          end  
-          wp = WEEL::Position.new(position, :at, nil)
-          ipc[:at] = [wp.position]
-        end
-        @__weel_positions << wp
-        Thread.current[:branch_position] = wp
-
-        handlerwrapper.inform_position_change(ipc)
-
-        # searchmode position is after, jump directly to vote_sync_after
-        raise Signal::Proceed if searchmode == :after
-
-        raise Signal::Stop unless handlerwrapper.vote_sync_before
-
-        case type
-          when :manipulate
-            if block_given?
-              handlerwrapper.inform_activity_manipulate
-              mr = ManipulateRealization.new(@__weel_data,@__weel_endpoints,@__weel_status)
-              status = nil
-              parameters.delete_if do |para|
-                status = para if para.is_a?(Status)
-                para.is_a?(Status)
-              end
-              case blk.arity
-                when 1; mr.instance_exec(parameters,&blk)
-                when 2; mr.instance_exec(parameters,status,&blk)
-                else
-                  mr.instance_eval(&blk)
-              end
-              handlerwrapper.inform_manipulate_change(
-                (mr.changed_status ? @__weel_status : nil), 
-                (mr.changed_data.any? ? mr.changed_data.uniq : nil),
-                (mr.changed_endpoints.any? ? mr.changed_endpoints.uniq : nil)
-              )
-              handlerwrapper.inform_activity_done
-              wp.detail = :after
-              handlerwrapper.inform_position_change :after => [wp.position]
-            end  
-          when :call
-            params = { }
-            passthrough = @__weel_search_positions[position] ? @__weel_search_positions[position].passthrough : nil
-            parameters.each do |p|
-              if p.class == Hash && parameters.length == 1
-                params = p
-              else  
-                if !p.is_a?(Symbol) || !@__weel_data.include?(p)
-                  raise("not all passed parameters are data elements")
-                end
-                params[p] = @__weel_data[p]
-              end
-            end
-            # handshake call and wait until it finished
-            handlerwrapper.activity_handle passthrough, params
-            Thread.current[:continue].wait unless Thread.current[:nolongernecessary] || self.__weel_state == :stopping || self.__weel_state == :stopped
-
-            if Thread.current[:nolongernecessary]
-              handlerwrapper.activity_no_longer_necessary 
-              raise Signal::NoLongerNecessary
-            end  
-            if self.__weel_state == :stopping
-              handlerwrapper.activity_stop
-              wp.passthrough = handlerwrapper.activity_passthrough_value
-            end  
-
-            if wp.passthrough.nil? && block_given?
-              handlerwrapper.inform_activity_manipulate
-              mr = ManipulateRealization.new(@__weel_data,@__weel_endpoints,@__weel_status)
-              status = handlerwrapper.activity_result_status
-              case blk.arity
-                when 1; mr.instance_exec(handlerwrapper.activity_result_value,&blk)
-                when 2; mr.instance_exec(handlerwrapper.activity_result_value,(status.is_a?(Status)?status:nil),&blk)
-                else
-                  mr.instance_eval(&blk)
-              end  
-              handlerwrapper.inform_manipulate_change(
-                (mr.changed_status ? @__weel_status : nil), 
-                (mr.changed_data.any? ? mr.changed_data.uniq : nil),
-                (mr.changed_endpoints.any? ? mr.changed_endpoints.uniq : nil)
-              )
-            end
-            if wp.passthrough.nil?
-              handlerwrapper.inform_activity_done
-              wp.detail = :after
-              handlerwrapper.inform_position_change :after => [wp.position]
-            end  
-        end
-        raise Signal::Proceed
-      rescue Signal::SkipManipulate, Signal::Proceed
-        if self.__weel_state != :stopping && !handlerwrapper.vote_sync_after
-          self.__weel_state = :stopping
-          wp.detail = :unmark
-        end
-      rescue Signal::NoLongerNecessary
-        @__weel_positions.delete wp
-        Thread.current[:branch_position] = nil
-        wp.detail = :unmark
-        handlerwrapper.inform_position_change :unmark => [wp.position]
-      rescue Signal::StopSkipManipulate, Signal::Stop
-        self.__weel_state = :stopping
-      rescue => err
-        handlerwrapper.inform_activity_failed err
-        self.__weel_state = :stopping
-      end
-    end # }}}
+    def call(position, endpoint, parameters={}, code=nil, &blk)
+      __weel_activity(position,:call,endpoint,parameters,code||blk)
+    end  
+    def manipulate(position, code=nil, &blk)
+      __weel_activity(position,:manipulate,nil,{},code||blk)
+    end  
     
     # Parallel DSL-Construct
     # Defines Workflow paths that can be executed parallel.
@@ -555,6 +441,10 @@ class WEEL
       Thread.current[:mutex] ||= Mutex.new
       Thread.current[:mutex].synchronize do
         return if Thread.current[:alternative_mode] == :exclusive && Thread.current[:alternative_executed][-1] = true
+        if condition.is_a?(String) && !__weel_sim
+          handlerwrapper = @__weel_handlerwrapper.new @__weel_handlerwrapper_args
+          condition = handlerwrapper.test_condition(ReadStructure.new(@__weel_data,@__weel_endpoints),__condition)
+        end
         Thread.current[:alternative_executed][-1] = true if condition
       end  
       yield if __weel_is_in_search_mode || __weel_sim || condition
@@ -583,7 +473,7 @@ class WEEL
 
     # Defines a Cycle (loop/iteration)
     def loop(condition)# {{{ 
-      unless condition.is_a?(Array) && condition[0].is_a?(Proc) && [:pre_test,:post_test].include?(condition[1])
+      unless condition.is_a?(Array) && (condition[0].is_a?(Proc) || condition[0].is_a?(String)) && [:pre_test,:post_test].include?(condition[1])
         raise "condition must be called pre_test{} or post_test{}"
       end
       return if self.__weel_state == :stopping || self.__weel_state == :stopped || Thread.current[:nolongernecessary]
@@ -596,20 +486,21 @@ class WEEL
         yield
         __weel_sim_stop(:loop,hw,pos,:testing=>condition[1])
         return
-      end  
+      end
+      handlerwrapper = @__weel_handlerwrapper.new @__weel_handlerwrapper_args unless condition[0].is_a?(Proc)
       case condition[1]
         when :pre_test
-          yield while condition[0].call && self.__weel_state != :stopping && self.__weel_state != :stopped
+          yield while (condition[0].is_a?(Proc) ? condition[0].call : handlerwrapper.test_condition(ReadStructure.new(@__weel_data,@__weel_endpoints),condition[0])) && self.__weel_state != :stopping && self.__weel_state != :stopped
         when :post_test
-          begin; yield; end while condition[0].call && self.__weel_state != :stopping && self.__weel_state != :stopped
+          begin; yield; end while (condition[0].is_a?(Proc) ? condition[0].call : handlerwrapper.test_condition(ReadStructure.new(@__weel_data,@__weel_endpoints),condition[0])) && self.__weel_state != :stopping && self.__weel_state != :stopped
       end
     end # }}}
 
-    def pre_test(&blk)# {{{
-      [blk, :pre_test]
+    def pre_test(code=nil,&blk)# {{{
+      [code || blk, :pre_test]
     end # }}}
-    def post_test(&blk)# {{{
-      [blk, :post_test]
+    def post_test(code=nil,&blk)# {{{
+      [code || blk, :post_test]
     end # }}}
 
     def status # {{{
@@ -623,6 +514,159 @@ class WEEL
     end # }}}
 
   private
+    def __weel_activity(position, type, endpoint, parameters, code)# {{{
+      position = __weel_position_test position
+      begin
+        searchmode = __weel_is_in_search_mode(position)
+        return if searchmode == true
+        return if self.__weel_state == :stopping || self.__weel_state == :stopped || Thread.current[:nolongernecessary]
+
+        Thread.current[:continue] = Continue.new
+        handlerwrapper = @__weel_handlerwrapper.new @__weel_handlerwrapper_args, @__weel_endpoints[endpoint], position, Thread.current[:continue]
+
+        if __weel_sim
+          handlerwrapper.simulate(:activity,:none,position,Thread.current[:branch_sim_pos],:parameters=>parameters, :endpoint => endpoint, :type => type)
+          return
+        end
+
+        ipc = {}
+        if searchmode == :after
+          wp = WEEL::Position.new(position, :after, nil)
+          ipc[:after] = [wp.position]
+        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].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].position rescue nil
+          end  
+          wp = WEEL::Position.new(position, :at, nil)
+          ipc[:at] = [wp.position]
+        end
+        @__weel_positions << wp
+        Thread.current[:branch_position] = wp
+
+        handlerwrapper.inform_position_change(ipc)
+
+        # searchmode position is after, jump directly to vote_sync_after
+        raise Signal::Proceed if searchmode == :after
+
+        case type
+          when :manipulate
+            raise Signal::Stop unless handlerwrapper.vote_sync_before
+
+            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)
+                mr.instance_eval(&code)
+              elsif code.is_a?(String)  
+                mr = ManipulateStructure.new(@__weel_data,@__weel_endpoints,@__weel_status)
+                handlerwrapper.manipulate(mr,code)
+              end  
+              handlerwrapper.inform_manipulate_change(
+                ((mr && mr.changed_status) ? @__weel_status : nil), 
+                ((mr && mr.changed_data.any?) ? mr.changed_data.uniq : nil),
+                ((mr && mr.changed_endpoints.any?) ? mr.changed_endpoints.uniq : nil)
+              )
+              handlerwrapper.inform_activity_done
+              wp.detail = :after
+              handlerwrapper.inform_position_change :after => [wp.position]
+            end  
+          when :call
+            params = { }
+            case parameters 
+              when String
+                code = parameters
+                parameters = nil
+              when Hash
+                parameters.each do |k,p|
+                  if p.is_a?(Symbol) && @__weel_data.include?(p)
+                    params[k] = @__weel_data[p]
+                  elsif k == :code && p.is_a?(String)
+                    code = p
+                  else
+                    params[k] = p
+                  end
+                end  
+              when Array  
+                parameters.each_with_index do |p,i|
+                  if p.is_a?(Symbol) && @__weel_data.include?(p)
+                    params[p] = @__weel_data[p]
+                  else
+                    params[i] = p
+                  end  
+                end
+              else  
+                raise("invalid parameters")
+            end
+            raise Signal::Stop unless handlerwrapper.vote_sync_before(params)
+
+            passthrough = @__weel_search_positions[position] ? @__weel_search_positions[position].passthrough : nil
+            # handshake call and wait until it finished
+            handlerwrapper.activity_handle passthrough, params
+            Thread.current[:continue].wait unless Thread.current[:nolongernecessary] || self.__weel_state == :stopping || self.__weel_state == :stopped
+
+            if Thread.current[:nolongernecessary]
+              handlerwrapper.activity_no_longer_necessary 
+              raise Signal::NoLongerNecessary
+            end  
+            if self.__weel_state == :stopping
+              handlerwrapper.activity_stop
+              wp.passthrough = handlerwrapper.activity_passthrough_value
+            end  
+
+            if wp.passthrough.nil? && (code.is_a?(Proc) || code.is_a?(String))
+              handlerwrapper.inform_activity_manipulate
+              status = handlerwrapper.activity_result_status
+              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,(status.is_a?(Status)?status:nil),&code)
+                  else
+                    mr.instance_eval(&code)
+                end  
+              elsif code.is_a?(String)  
+                mr = ManipulateStructure.new(@__weel_data,@__weel_endpoints,@__weel_status)
+                handlerwrapper.manipulate(mr,code,handlerwrapper.activity_result_value,(status.is_a?(Status)?status:nil))
+              end
+              handlerwrapper.inform_manipulate_change(
+                (mr.changed_status ? @__weel_status : nil), 
+                (mr.changed_data.any? ? mr.changed_data.uniq : nil),
+                (mr.changed_endpoints.any? ? mr.changed_endpoints.uniq : nil)
+              )
+            end
+            if wp.passthrough.nil?
+              handlerwrapper.inform_activity_done
+              wp.detail = :after
+              handlerwrapper.inform_position_change :after => [wp.position]
+            end  
+        end
+        raise Signal::Proceed
+      rescue Signal::SkipManipulate, Signal::Proceed
+        if self.__weel_state != :stopping && !handlerwrapper.vote_sync_after
+          self.__weel_state = :stopping
+          wp.detail = :unmark
+        end
+      rescue Signal::NoLongerNecessary
+        @__weel_positions.delete wp
+        Thread.current[:branch_position] = nil
+        wp.detail = :unmark
+        handlerwrapper.inform_position_change :unmark => [wp.position]
+      rescue Signal::StopSkipManipulate, Signal::Stop
+        self.__weel_state = :stopping
+      rescue => err
+        handlerwrapper.inform_activity_failed err
+        self.__weel_state = :stopping
+      end
+    end # }}}
+
     def __weel_recursive_print(thread,indent='')# {{{
       p "#{indent}#{thread}"
       if thread[:branches]

data/test/TestHandlerWrapper.rb

@@ -85,4 +85,11 @@ class TestHandlerWrapper < WEEL::HandlerWrapperBase
     $long_track += "---> STATE #{newstate}\n"
     $short_track << "|#{newstate}|"
   end
+
+  def manipulate(mr,code,result=nil,status=nil)
+    mr.instance_eval(code)
+  end
+  def test_condition(mr,code)
+    mr.instance_eval(code)
+  end
 end

data/test/TestWorkflow.rb

@@ -10,26 +10,26 @@ class TestWorkflow < WEEL
   data :x => 'begin_'
   
   control flow do
-    activity :a1_1, :call, :endpoint1 do |result|
+    call :a1_1, :endpoint1 do |result|
       data.x += "#{result}"
     end
     parallel :wait => 2 do
       parallel_branch do
-        activity :a2_1_1, :call, :endpoint1
+        call :a2_1_1, :endpoint1
       end
       parallel_branch do
-        activity :a2_2_1, :call, :endpoint1
+        call :a2_2_1, :endpoint1
       end
     end
-    activity :a3, :manipulate do
+    manipulate :a3 do
       data.x += '_end'
     end
     choose do
       alternative data.x != nil do
-        activity :a4a, :call, :endpoint1
+        call :a4a, :endpoint1
       end
       otherwise do
-        activity :a4b, :call, :endpoint1
+        call :a4b, :endpoint1
       end
     end
   end