openwferu 0.9.1 → 0.9.2

data/{README → README.txt}

@@ -17,12 +17,12 @@ OpenWFEru is a Ruby port of the OpenWFE workflow engine
 (http://www.openwfe.org).  It is a complete rewrite in Ruby 
 so does not need to use the Java-based engine from OpenWFE.
 
-OpenWFEru was initially implemented in San Joaquin de Flores, Costa Rica.
+OpenWFEru was initially implemented in San Joaquin de Flores, Costa Rica. And then in Yokohama, Japan.
 
 One project goal for OpenWFEru is compatibility with its
 Java based cousin so workflows defined for the Java engine
 should work with the Ruby implementation.  There are
-some incompatibilities between each implementatio.
+some incompatibilities between each implementation.
 
 TODO: Document implementation differences
 
@@ -37,29 +37,28 @@ Creating an workflow engine instance
 
   # Create an engine to launch the flow
   engine = OpenWFEru::Engine.new
-  engine.register_participant('test-.*', 
-                              OpenWFEru::PrintParticipant.new())
+  engine.register_participant('test-.*', OpenWFEru::PrintParticipant.new())
+
   # Create a flow definition and assign to a new instance
   flow = '''<process-definition name="equals_0" revision="0">
-    <sequence>
+    <if>
         <equals value="a" other-value="a" />
         <print>${field:__result__}</print>
-    </sequence>
+    </if>
   </process-definition>'''
-  li = OpenWFE::LaunchItem.new
-  li.workflowDefinitionUrl = "field:__definition"
-  li.attributes['__definition'] = flow
+  li = OpenWFE::LaunchItem.new(flow)
+
   # Launch the instance
   engine.launch(li)
+
   # Examine it
-  exp_storage = engine.application_context[OpenWFEru::S_EXPRESSION_STORAGE]
-  pp exp_storage
+  pp engine.get_expression_storage
 
 == How to help
 
 If you want to help hacking on openwferu you'll probably want the following
 libraries: 
-[+rake+] Handle builds, generating documentation, and running unit tests
+[rake] Handle builds, generating documentation, and running unit tests
 [rubygems] Handles creation of the gems
 [rote] A framework being used to help with managing the offline written docs
 [redcloth] Openwferu uses textile-markup for its docs.  Redcloth provides an engine for it.
@@ -70,6 +69,7 @@ It's best if you use gems to install these as the process can get rather
 tedious by hand.
 
 === Prerequisites
+
 You'll need libxml2-dev in order to compile the native libraries
 for libxml.  Please check your your packaging system for the appropriate
 name.
@@ -78,6 +78,7 @@ On Ubuntu you can install libxml2 with:
   sudo apt-get install libxml2-dev
 
 === Ruby Libraries Install
+
 1. gem install -r rake
 2. gem install -r rote redcloth 
 3. gem install -r tidy    
@@ -87,9 +88,11 @@ On Ubuntu you can install libxml2 with:
 
 The main project site lives at rubyforge at:
 http://rubyforge.org/projects/openwferu
+or
+http://ru.openwfe.org
 
 In the meantime the old site hosted at openwfe.org is at:
 http://www.openwfe.org/openwfe-ruby.html
 
-If you're interested in helping :  john at openwfe dot org
+If you're interested in helping :  http://groups.google.com/group/openwferu-dev/topics
 

data/bin/validate-workflow.rb

@@ -4,11 +4,11 @@
 # Purpose:       A helper script that validates a workflow document against
 #                a XML Schema
 # Author:        Alain Hoang
-# Version:       0.1
 # Notes:         Uses Ruby's libxml library to handle the parsing
 
 # Stdlib
 require 'net/http'
+require 'optparse'
 require 'uri'
 # From the gems archive
 require 'rubygems'
@@ -16,42 +16,66 @@ require 'xml/libxml'
 
 
 module OpenWFEru
+    FLOWDEF_URL = 'http://www.openwfe.org/flowdef.xsd'
     # Validates a workflow definition against the Workflow XML Schema
     # defined at http://www.openwfe.org/flowdef.xsd
     class WorkflowValidator
-        OPENWFE_FLOWDEF_URL='http://www.openwfe.org/flowdef.xsd'
+        
+        attr_accessor :schema_url
+        attr_accessor :args
 
-        # Class method for validating a xml file against the
-        # OpenWFE XML Schema
-        def WorkflowValidator.validate(file)
-            # Should only be initialized once during the lifetime
-            # of the program
-            if not defined? @@schema
-                xsd_str = Net::HTTP.get URI.parse(OPENWFE_FLOWDEF_URL)
-                @@schema = XML::Schema.from_string(xsd_str)
-            end
+        # Create a validator object using a WorkflowValidatorArgs object
+        def initialize(args)
+            @args = args
+            @args[:schema_url] ||= FLOWDEF_URL
+
+            xsd_str = Net::HTTP.get URI.parse(@args[:schema_url])
+            @schema = XML::Schema.from_string(xsd_str)
+        end
+
+        # validates a xml file against the OpenWFE XML Schema
+        def validate(file)
 	        xmldoc = XML::Document.file(file)
-	        xmldoc.validate_schema(@@schema)
+	        xmldoc.validate_schema(@schema)
         end
     end
-end
 
-def usage
-    print "Usage: #{$0} <workflow def> [workflow def] [workflow def] ...\n"
-    print "  <workflow def> - workflow definition file\n"
+    class WorkflowValidatorArgs < Hash
+        # Create an arguments object to send to a WorkflowValidator object
+        def initialize(args)
+            super()
+            opts = OptionParser.new do |opts|
+                opts.banner =  "Usage: #$0 [-u url] <workflow def> [workflow def] ..."
+    
+                opts.on('-u', '--url URL', 'Use XML Schema at URL') do |url|
+                    self[:schema_url] = url
+                end
+    
+                opts.on_tail('-h', '--help', 'display this help and exit') do
+                    puts opts
+                    exit
+                end
+            end
+            opts.parse!(args)
+            # Check for no args and exit if so
+            if args.empty?
+                puts opts
+                exit 1
+            end
+        end
+    end
 end
 
+
 def main
-	# Make sure we have at least one argument or bail
-	if ARGV.length == 0
-	    usage
-	    exit 1
-	end
+    # Create the arguments object and the validator object
+    args = OpenWFEru::WorkflowValidatorArgs.new(ARGV)
+    validator = OpenWFEru::WorkflowValidator.new(args)
 
     # Loop through all arguments and validate the file
 	ARGV.each do |f|
         print "Trying to validate #{f}...  "
-        if OpenWFEru::WorkflowValidator.validate(f)
+        if FileTest.exists?(f) && validator.validate(f)
             print "PASSED\n"
         else
             print "FAILED\n"

data/examples/README.txt

@@ -0,0 +1,8 @@
+= OpenWFEru examples
+
+you can run quotereporter.rb with
+
+   ruby -r path/to/openwferu/lib/ quotereporter.rb
+
+It will fetch a few quotes for stocks and produce an atom feed file (atom_feed.xml)
+

data/examples/homeworkreview.rb

@@ -0,0 +1,66 @@
+
+### EXAMPLE IN PREPARATION ###
+
+#
+# an OpenWFEru example
+#
+
+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/quotereporter.rb

@@ -0,0 +1,154 @@
+
+#
+# an OpenWFEru example
+#
+
+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
+                    #
+                    # the four 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
+

data/lib/{openwferu.rb → openwfe.rb}

@@ -1,6 +1,6 @@
 #
-#<tt>
-# Copyright (c) 2005-2006, John Mettraux, OpenWFE.org
+#--
+# Copyright (c) 2005-2007, John Mettraux and Alain Hoang, OpenWFE.org
 # All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
@@ -28,8 +28,6 @@
 # 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.
-#</tt>
-#
 #++
 #
 # = openwferu -- Open Workflow Engine in Ruby
@@ -38,8 +36,8 @@
 # referenced as a library via a require statement.
 #
 
-require 'workitem'
-require 'ru/engine'
-require 'ru/rudefinitions'
-require 'ru/participants'
+require 'openwfe/workitem'
+require 'openwfe/engine'
+require 'openwfe/rudefinitions'
+require 'openwfe/participants'
 

data/lib/{ru → openwfe}/contextual.rb

@@ -1,6 +1,6 @@
 #
 #--
-# Copyright (c) 2006, John Mettraux, OpenWFE.org
+# Copyright (c) 2006-2007, John Mettraux, Nicolas Modrzyk OpenWFE.org
 # All rights reserved.
 # 
 # Redistribution and use in source and binary forms, with or without 
@@ -37,9 +37,9 @@
 # "made in Japan"
 #
 # John Mettraux at openwfe.org
-#
+# Nicolas Modrzyk at openwfe.org
 
-module OpenWFEru
+module OpenWFE
 
     module Contextual
 
@@ -59,6 +59,14 @@ module OpenWFEru
             end
             return @application_context[key]
         end
+        
+        #
+        # use reflection to instanciate the new service,and 
+        # add it to the application context
+        def init_service (service_name, service_class)
+            @application_context[service_name] = \
+                service_class.new(service_name,@application_context)
+        end
 
     end