ruote 0.9.18

data/examples/flowtracing.rb

@@ -0,0 +1,24 @@
+
+#
+# a little script that traces the flow given as input
+#
+
+require 'rubygems'
+
+require 'openwfe/expressions/raw_prog'
+require 'openwfe/tools/flowtracer'
+
+class MyProcessDefinition < OpenWFE::ProcessDefinition
+    def make
+        process_definition :name => "mpd", :revision => "0" do
+            sequence do
+                participant "alpha"
+                set :field => "toto", :value => "toto value"
+                participant "bravo"
+            end
+        end
+    end
+end
+
+OpenWFE::trace_flow(MyProcessDefinition)
+

data/examples/homeworkreview.rb

@@ -0,0 +1,68 @@
+
+### EXAMPLE IN PREPARATION ###
+
+#
+# an OpenWFEru example
+#
+
+require 'rubygems'
+
+require 'openwfe/engine/engine'
+require 'openwfe/expressions/raw_prog'
+#require 'openwfe/participants/soapparticipants'
+#require 'openwfe/participants/atomparticipants'
+
+
+#
+# the process definition
+# 
+# instead of using the classical OpenWFE XML process definitions, we
+# define the flow as a Ruby class
+
+class ReviewFlow < OpenWFE::ProcessDefinition
+    def make
+        process_definition :name => "homework_review", :revision => "0.1" do
+            sequence do
+            end
+        end
+    end
+end
+
+#
+# the engine
+#
+# a simple in memory engine, no persistence whatsoever for now.
+
+engine = OpenWFE::Engine.new
+
+#
+# The Participants
+#
+# Ideally participants are shared by more than one process definition
+# (a person is usually part of more than one business process in
+# his organization)
+
+# a small debug participant, as you can see, a participant can 
+# directly be a ruby block (which receives the workitem)
+# (it's commented out at the end of the flow)
+#
+engine.register_participant("puts_workitem") do |workitem|
+    puts
+    puts workitem.to_s
+    puts
+end
+
+#
+# launching
+
+launchitem = LaunchItem.new(QuoteLookupFlow)
+    #
+    # Passing the process definition class as the unique 
+    # LaunchItem parameter
+
+launchitem.symbols = "aapl, sunw, msft, lnux"
+    #
+    # directly setting the value for the field "symbols"
+
+engine.launch(launchitem)
+

data/examples/kotoba.rb

@@ -0,0 +1,22 @@
+
+require 'pp'
+require 'rubygems'
+require 'openwfe/util/kotoba'
+
+3.times do
+
+    i = (rand * 1000000).to_i
+    s = Kotoba::from_integer i
+
+    puts "#{i} => #{s}"
+    puts "#{s} => #{Kotoba::to_integer(s)}"
+        # forth and back
+
+    a = Kotoba::split s
+
+    print "#{s} => "; pp a
+        # showing how the 'word' is split
+
+    puts "."
+end
+

data/examples/mano_tracker.rb

@@ -0,0 +1,172 @@
+#
+#--
+# Copyright (c) 2007, John Mettraux OpenWFE.org
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without 
+# modification, are permitted provided that the following conditions are met:
+# 
+# . Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.  
+# 
+# . Redistributions in binary form must reproduce the above copyright notice, 
+#   this list of conditions and the following disclaimer in the documentation 
+#   and/or other materials provided with the distribution.
+# 
+# . Neither the name of the "OpenWFE" nor the names of its contributors may be
+#   used to endorse or promote products derived from this software without
+#   specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+# POSSIBILITY OF SUCH DAMAGE.
+#++
+#
+# $Id: definitions.rb 2725 2006-06-02 13:26:32Z jmettraux $
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+#
+# see
+# http://groups.google.com/group/openwferu-users/browse_frm/thread/81294030fc52cd04
+# for the context of this example
+#
+
+require 'rubygems'
+
+#require 'openwfe/engine/engine'
+require 'openwfe/engine/file_persisted_engine'
+require 'openwfe/expressions/raw_prog'
+require 'openwfe/worklist/storeparticipant'
+
+
+#
+# The process definition
+# (using a programmatic process definition instead of an XML process definition)
+
+class TrackerDefinition < OpenWFE::ProcessDefinition
+    def make
+
+        _loop do
+            participant "${f:creative}"
+            participant "${f:analyst}"
+
+            _break :if => "${f:done}"
+                #
+                # loops until the analyst sets the value of the field
+                # 'done' to true.
+        end
+            #
+            # 'loop' and 'break' are ruby keywords, they have to be
+            # preceded by an underscore '_' to be used in their 
+            # OpenWFEru sense.
+    end
+end
+
+#
+# prepare the engine and the participants
+
+ANALYSTS = [ "Mano", "Matt", "Moe" ]
+CREATIVES = [ "Jamie", "Jeff", "John", "Jeremy" ]
+
+#
+# instantiate the engine (a transient one is sufficient for the example)
+
+#$engine = OpenWFE::Engine.new
+    # no persistence
+
+#$engine = OpenWFE::FilePersistedEngine.new
+    # persistence, but no caching (worst performance)
+
+$engine = OpenWFE::CachedFilePersistedEngine.new
+    # persistence and performance
+
+$analyst_stores = {}
+$creative_stores = {}
+    #
+    # gathering the stores for our fictitious organization
+
+def add_stores (names, store_map)
+    names.each do |name|
+        #hp = OpenWFE::HashParticipant.new
+        #$engine.register_participant(name, hp)
+        hp = $engine.register_participant(name, OpenWFE::YamlParticipant)
+        store_map[name] = hp
+    end
+end
+
+add_stores(ANALYSTS, $analyst_stores)
+add_stores(CREATIVES, $creative_stores)
+
+#
+# a quick method for launching a tracker process instance
+#
+def launch_tracker (analyst_name, creative_name, title, item_url)
+
+    li = LaunchItem.new(TrackerDefinition)
+        #
+        # preparing a lunchitem ;) around our TrackerDefinition
+
+    li.analyst = analyst_name
+    li.creative = creative_name
+    li.title = title
+    li.item_url = item_url
+        #
+        # filling the workitem with attributes
+
+    $engine.launch(li)
+end
+
+# the system is ready...
+
+
+#
+# (...)
+#
+# Later it can be used as follow
+
+fei = launch_tracker(
+    "Mano", 
+    "Jamie", 
+    "new logo for company", 
+    "http://openwferu.rubyforge.org/images/openwfe-logo.png")
+
+puts "launched tracker process #{fei.workflow_instance_id}"
+
+#
+# the creative Jamie can browse the items he has to treat with :
+
+jamie_store = $analyst_stores["Jamie"]
+
+first_fei = nil
+
+jamie_store.each do |fei, workitem|
+    first_fei = fei unless fei
+    puts " - #{fei.workflow_instance_id} -- #{workitem.title}"
+end
+
+workitem = jamie_store[first_fei]
+
+# play with the workitem and then send it back to the engine
+
+workitem.item_url = "some other url"
+    #
+    # actually just changing the item_url
+
+jamie_store.forward(workitem)
+
+# ...
+

data/examples/openwferu.rb

@@ -0,0 +1,58 @@
+
+require 'rubygems'
+require 'openwfe/def'
+require 'openwfe/workitem'
+require 'openwfe/engine/engine'
+
+#
+# instantiating an engine
+
+engine = OpenWFE::Engine.new
+
+#
+# adding some participants
+
+engine.register_participant :alice do |workitem|
+    puts "alice got a workitem..."
+    workitem.alice_comment = "this thing looks interesting"
+end
+
+engine.register_participant :bob do |workitem|
+    puts "bob got a workitem..."
+    workitem.bob_comment = "not for me, I prefer VB"
+    workitem.bob_comment2 = "Bob rules"
+end
+
+engine.register_participant :summarize do |workitem|
+    puts 
+    puts "summary of process #{workitem.fei.workflow_instance_id}"
+    workitem.attributes.each do |k, v|
+        next unless k.match ".*_comment$"
+        puts " - #{k} : '#{v}'"
+    end
+end
+
+#
+# a process definition
+
+class TheProcessDefinition0 < OpenWFE::ProcessDefinition
+    sequence do
+        concurrence do
+            participant :alice
+            participant :bob
+        end
+        participant :summarize
+    end
+end
+
+#
+# launching the process
+
+li = OpenWFE::LaunchItem.new(TheProcessDefinition0)
+
+li.initial_comment = "please give your impressions about http://ruby-lang.org"
+
+fei = engine.launch(li)
+
+engine.wait_for fei
+

data/examples/quotereporter.rb

@@ -0,0 +1,157 @@
+
+#
+# an OpenWFEru example
+#
+
+require 'rubygems'
+
+require 'openwfe/engine/engine'
+require 'openwfe/expressions/raw_prog'
+require 'openwfe/participants/soapparticipants'
+require 'openwfe/participants/atomparticipants'
+
+
+#
+# the process definition
+# 
+# instead of using the classical OpenWFE XML process definitions, we
+# define the flow as a Ruby class
+
+class QuoteLookupFlow < OpenWFE::ProcessDefinition
+    def make
+        process_definition :name => "quote_lookup", :revision => "0.1" do
+            sequence do
+
+                #
+                # lookup quotes
+
+                iterator :on_field_value => "symbols", :to_field => "symbol" do
+                    sequence do
+
+                        set \
+                            :field => "quote_${f:__ip__}_name", 
+                            :field_value => "symbol"
+
+                        participant :quote_service
+
+                        set \
+                            :field => "quote_${f:__ip__}_value", 
+                            :field_value => "__result__"
+                    end
+                end
+
+                #
+                # update feed
+
+                set :field => "atom_entry_title" do
+                    "quote feed at ${r:Time.now}"
+                end
+                    #
+                    # wrapping some ruby code for eval at runtime 
+                    # with ${r: ruby code ... }
+
+                participant :feed
+
+                #participant :ref => "puts_workitem"
+                #participant :ref => :puts_workitem
+                #participant "puts_workitem"
+                #participant :puts_workitem
+                puts_workitem
+                    #
+                    # the five notations are equivalent
+            end
+        end
+    end
+end
+
+#
+# the engine
+#
+# a simple in memory engine, no persistence whatsoever for now.
+
+engine = OpenWFE::Engine.new
+
+#
+# The Participants
+#
+# Ideally participants are shared by more than one process definition
+# (a person is usually part of more than one business process in
+# his organization)
+
+# the participant that looks up the quote values
+#
+quote_service = OpenWFE::SoapParticipant.new(
+    "http://services.xmethods.net/soap",        # service URI
+    "urn:xmethods-delayed-quotes",              # namespace
+    "getQuote",                                 # operation name
+    [ "symbol" ])                               # param arrays (workitem fields)
+
+engine.register_participant("quote_service", quote_service)
+
+# the feed : at most 10 feed entries are kept.
+#
+# The entry template is specified as a block returning the template 
+# (a string containing xhtml).
+#
+# The feed is outputted in the current working directory ./atom_feed.xml
+#
+feed = OpenWFE::AtomParticipant.new(10) do 
+    | flow_expression, participant, workitem |
+    
+    #
+    # the template (xhtml by default) is generated via a block
+
+    s = "<h3>quotes</h3>"
+
+    s << "<ul>"
+
+    workitem.__ic__.times do |i|
+        #
+        # within an iteration, the count of iterations is stored in the
+        # workitem field "__ic__"
+        #
+        s << "<li>"
+        s << workitem.attributes["quote_#{i}_name"].to_s
+        s << " : "
+        s << workitem.attributes["quote_#{i}_value"].to_s
+        s << "</li>\n"
+    end
+
+    s << "</ul>"
+end
+engine.register_participant("feed", feed)
+
+# a small debug participant, as you can see, a participant can 
+# directly be a ruby block (which receives the workitem)
+# (it's commented out at the end of the flow)
+#
+engine.register_participant("puts_workitem") do |workitem|
+    puts
+    puts workitem.to_s
+    puts
+end
+
+#
+# launching (not lunching)
+
+launchitem = LaunchItem.new(QuoteLookupFlow)
+    #
+    # Passing the process definition class as the unique 
+    # LaunchItem parameter
+
+launchitem.symbols = "aapl, sunw, msft, lnux"
+    #
+    # directly setting the value for the field "symbols"
+
+engine.launch(launchitem)
+
+# in this example, the engine is used once with only one process definition,
+# but an OpenWFE engine is made to run multiple different process instances.
+
+# as an extension example, to produce a feed for the next ten hours you would :
+#
+# 10.times do 
+#     engine.launch(launchitem)
+#     sleep (3600) # one hour
+# end
+