ruote 0.9.20 → 2.1.1

data/lib/ruote/parser/ruby_dsl.rb

@@ -0,0 +1,85 @@
+#--
+# Copyright (c) 2005-2010, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+
+module Ruote
+
+  # Not really a parser, more an AST builder.
+  #
+  def self.define (*attributes, &block)
+
+    RubyDsl.create_branch('define', attributes, &block)
+  end
+
+  def self.process_definition (*attributes, &block)
+
+    define(*attributes, &block)
+  end
+
+  # :nodoc:
+  #
+  module RubyDsl
+
+    class BranchContext
+
+      def initialize (name, attributes)
+
+        @name = name
+        @attributes = attributes
+        @children = []
+      end
+
+      def method_missing (m, *args, &block)
+
+        @children.push(
+          Ruote::RubyDsl.create_branch(m.to_s, args, &block))
+      end
+
+      def to_a
+
+        [ @name, @attributes, @children ]
+      end
+    end
+
+    def self.create_branch (name, attributes, &block)
+
+      while name[0, 1] == '_'
+        name = name[1..-1]
+      end
+
+      h = attributes.inject({}) { |h1, a|
+        a.is_a?(Hash) ? h1.merge!(a) : h1[a] = nil
+        h1
+      }.inject({}) { |h1, (k, v)|
+        h1[k.to_s] = v.is_a?(Symbol) ? v.to_s : v
+        h1
+      }
+
+      c = BranchContext.new(name, h)
+      c.instance_eval(&block) if block
+      c.to_a
+    end
+  end
+end
+

data/lib/ruote/parser/xml.rb

@@ -0,0 +1,92 @@
+#--
+# Copyright (c) 2005-2010, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+require 'rexml/parsers/sax2parser'
+require 'rexml/sax2listener'
+
+
+module Ruote
+
+  #
+  # Turns an XML string into a process definition tree.
+  #
+  module XmlParser
+
+    #
+    # A helper class to store the temporary tree while it gets parsed.
+    #
+    class Node
+
+      attr_reader :parent, :attributes, :children
+
+      def initialize (parent, name, attributes)
+
+        @parent = parent
+        @name = name
+        @attributes = attributes.inject({}) { |h, (k, v)|
+          h[k.gsub(/-/, '_')] = v
+          h
+        }
+        @children = []
+
+        parent.children << self if parent
+      end
+
+      def to_a
+        [ @name, @attributes, @children.collect { |c| c.to_a } ]
+      end
+    end
+
+    #
+    # Parses the XML string into a process definition tree (array of arrays).
+    #
+    def self.parse (s)
+
+      parser = REXML::Parsers::SAX2Parser.new(s)
+
+      root = nil
+      current = nil
+
+      # u, l, q, a <=> url, local, qname, attributes
+
+      parser.listen(:start_element) do |u, l, q, a|
+        current = Node.new(current, l.gsub(/-/, '_'), a)
+        root ||= current
+      end
+      parser.listen(:end_element) do |u, l, q, a|
+        current = current.parent
+      end
+
+      parser.listen(:characters) do |text|
+        t = text.strip
+        current.attributes[t] = nil if t.size > 0
+      end
+
+      parser.parse
+
+      root.to_a
+    end
+  end
+end
+

data/lib/ruote/part/block_participant.rb

@@ -0,0 +1,101 @@
+#--
+# Copyright (c) 2005-2010, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+require 'ruote/part/local_participant'
+
+
+module Ruote
+
+  #
+  # One of the simplest participants. Simply passes a workitem to a block
+  # of ruby code.
+  #
+  #   engine.register_participant :alpha do |workitem|
+  #     workitem.fields['time'] = Time.now
+  #   end
+  #
+  # This participant implicitely replies to the engine when the block execution
+  # is over.
+  #
+  # You can pass the flow_expression (participant expression) as well.
+  #
+  #   engine.register_participant :alpha do |workitem, flow_exp|
+  #     workitem.fields['amount'] = flow_exp.lookup_variable('amount')
+  #   end
+  #
+  #
+  # == do_not_thead
+  #
+  # By default, this participant (like most other participants) is executed
+  # in its own thread (in a Ruby runtime where EventMachine is running,
+  # EM.next_tick is used instead of a new thread).
+  #
+  # You can change that behaviour (beware block thats monopolises the whole
+  # engine !) by doing
+  #
+  #   alpha = engine.register_participant :alpha do |workitem|
+  #     workitem.fields['time'] = Time.now
+  #   end
+  #
+  #   alpha.do_not_thread = true
+  #
+  # (you could also override do_not_thread, the method ...)
+  #
+  class BlockParticipant
+
+    include LocalParticipant
+
+    attr_accessor :context
+    attr_accessor :do_not_thread
+
+    def initialize (block, opts)
+
+      @opts = opts
+      @block = block
+      @do_not_thread = false
+    end
+
+    def consume (workitem)
+
+      r = if @block.arity == 1
+
+        @block.call(workitem)
+      else
+
+        @block.call(
+          workitem, Ruote::Exp::FlowExpression.fetch(@context, workitem.h.fei))
+      end
+
+      workitem.result = r if r != nil && r != workitem
+
+      reply_to_engine(workitem)
+    end
+
+    def cancel (fei, flavour)
+
+      # do nothing
+    end
+  end
+end
+

data/lib/ruote/part/dispatch_pool.rb

@@ -0,0 +1,84 @@
+#--
+# Copyright (c) 2005-2010, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+
+module Ruote
+
+  #
+  # The class where despatchement of workitems towards [real] participant
+  # is done.
+  #
+  # Can be extended/replaced for better handling of Thread (why not something
+  # like a thread pool or no threads at all).
+  #
+  class DispatchPool
+
+    def initialize (context)
+
+      @context = context
+    end
+
+    def dispatch (msg)
+
+      participant = @context.plist.lookup(msg['participant_name'])
+
+      if participant.respond_to?(:do_not_thread) && participant.do_not_thread
+        do_dispatch(participant, msg)
+      else
+        do_threaded_dispatch(participant, msg)
+      end
+    end
+
+    protected
+
+    def do_dispatch (participant, msg)
+
+      workitem = Ruote::Workitem.new(msg['workitem'])
+
+      participant.consume(workitem)
+    end
+
+    def do_threaded_dispatch (participant, msg)
+
+      Thread.new do
+        begin
+
+          do_dispatch(participant, msg)
+
+        rescue Exception => e
+
+          #puts '/' * 80
+          #p e
+          #puts '/' * 80
+
+          @context.worker.handle_exception(
+            msg,
+            Ruote::Exp::FlowExpression.fetch(@context, msg['workitem']['fei']),
+            e)
+        end
+      end
+    end
+  end
+end
+

data/lib/ruote/part/hash_participant.rb

@@ -0,0 +1,91 @@
+#--
+# Copyright (c) 2005-2010, John Mettraux, jmettraux@gmail.com
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#
+# Made in Japan.
+#++
+
+require 'ruote/part/local_participant'
+
+
+module Ruote
+
+  #
+  # Storing workitems in-memory. Mainly used for testing purposes, but could
+  # prove useful for a transient ruote engine.
+  #
+  class HashParticipant
+
+    include LocalParticipant
+    include Enumerable
+
+    def initialize (opts=nil)
+
+      @items = {}
+    end
+
+    # No need for a separate thread when delivering to this participant.
+    #
+    def do_not_thread; true; end
+
+    def consume (workitem)
+
+      @items[workitem.fei.to_storage_id] = workitem
+    end
+
+    # Makes sure to remove the workitem from the in-memory hash.
+    #
+    def cancel (fei, flavour)
+
+      @items.delete(fei.to_storage_id)
+    end
+
+    # Removes the workitem from the in-memory hash and replies to the engine.
+    #
+    def reply (workitem)
+
+      @items.delete(workitem.fei.to_storage_id)
+      reply_to_engine(workitem)
+    end
+
+    # Returns the count of workitems stored in this participant.
+    #
+    def size
+
+      @items.size
+    end
+
+    # Iterates over the workitems stored in here.
+    #
+    def each (&block)
+
+      @items.each { |i| block.call(i) }
+    end
+
+    # A convenience method (especially when testing), returns the first
+    # (only ?) workitem in the participant.
+    #
+    def first
+
+      @items.values.first
+    end
+  end
+end
+