openwferu-extras 0.9.15 → 0.9.16

data/lib/openwfe/extras/participants/atompub_participants.rb

@@ -0,0 +1,286 @@
+#
+#--
+# 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.
+#++
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+#
+# this participant requires atom-tools from
+#
+# http://code.necronomicorp.com/trac/atom-tools 
+#
+# atom-tools' license is X11/MIT
+#
+
+require 'yaml'
+require 'rexml/document'
+
+require 'openwfe/participants/participants'
+
+require 'rubygems'
+
+begin
+    require 'atom/entry'
+    require 'atom/collection'
+rescue LoadError
+    #
+    # soft dependency on 'atom-tools'
+    #
+    puts
+    puts
+    puts "'atom/collection' is missing. You can install with :"
+    puts
+    puts "    [sudo] gem install atom-tools"
+    puts
+    puts
+    exit 1
+end
+
+require 'openwfe/participants/participant'
+require 'openwfe/participants/participants'
+
+
+module OpenWFE::Extras
+
+    #
+    # This participants posts (as in HTTP POST) a workitem 
+    # to an AtomPub enabled resource.
+    #
+    #     target_uri = "https://openwferu.wordpress.com/wp-app.php/posts"
+    #
+    #     params = {}
+    #     params[:username] = 'jmettraux'
+    #     params[:password] = ENV['WORDPRESS_PASSWORD']
+    #     params[:categories] = 'openwferu, test'
+    #     
+    #     engine.register_participant(
+    #         "app", OpenWFE::Extras::AtomPubParticipant.new target_uri, params)
+    #
+    # This base implementation dumps workitem as YAML in the entry content.
+    #
+    # See BlogParticipant for a human-oriented blog posting participant.
+    #
+    class AtomPubParticipant
+        include OpenWFE::LocalParticipant
+
+        #
+        # The URI to post to
+        #
+        attr_accessor :target_uri
+
+        attr_accessor :author_name, :author_uri
+
+
+        def initialize (target_uri, params)
+
+            @target_uri = target_uri
+
+            @username = params[:username]
+            @password = params[:password]
+
+            @author_name = \
+                params[:author_name] || self.class.name
+            @author_uri = \
+                params[:author_uri] || "http://openwferu.rubyforge.org"
+
+
+            @categories = params[:categories] || []
+            @categories = @categories.split(",") if @categories.is_a?(String)
+            @categories = Array(@categories)
+        end
+
+        #
+        # The incoming workitem will generate an atom entry that will
+        # get posted to the target URI.
+        #
+        # This consume() method returns the URI (as a String) where the
+        # just uploaded post can be edited.
+        #
+        def consume (workitem)
+
+            entry = Atom::Entry.new
+            entry.updated! # set updated time to now
+
+            render_author entry, workitem
+            render_categories entry, workitem
+            render_content entry, workitem
+
+            h = Atom::HTTP.new
+            h.user = @username
+            h.pass = @password
+            h.always_auth = :basic
+            
+            res = Atom::Collection.new(@target_uri, h).post!(entry)
+
+            # initial implementation
+            # don't catch an error, let the process fail
+
+            #res.read_body
+            extract_new_link res
+        end
+
+        protected
+
+            #
+            # This base implementation simply uses a YAML dump of the workitem
+            # as the post content (with a content type of 'html').
+            #
+            def render_content (entry, workitem)
+
+                entry.title = \
+                    workitem.participant_name + " " +
+                    workitem.fei.expression_id + " " +
+                    workitem.fei.workflow_instance_id
+
+                entry.content = workitem.to_yaml
+                entry.content["type"] = "html"
+            end
+
+            #
+            # This default implementation simply builds a single author
+            # out of the :author_name, :author_uri passed as initialization
+            # params.
+            #
+            def render_author (entry, workitem)
+
+                author = Atom::Author.new
+                author.name = author_name
+                author.uri = author_uri
+
+                entry.authors << author
+            end
+
+            #
+            # This base implementations simply adds the categories listed
+            # in the :categories initialization parameter.
+            # The target_uri is used as the scheme for the categories.
+            #
+            # You can override this method to add extra categories or to
+            # have completely different categories.
+            #
+            def render_categories (entry, workitem)
+
+                @categories.each do |s|
+
+                    c = Atom::Category.new
+
+                    c["scheme"] = @target_uri
+                    c["term"] = s.strip
+
+                    entry.categories << c
+                end
+            end
+
+            #
+            # Extracts the link of the newly created resource (newly posted blog
+            # entry), and returns it as a String.
+            #
+            def extract_new_link (response)
+
+                doc = REXML::Document.new response.read_body
+
+                #REXML::XPath.first(doc.root, "//link[@rel='edit']")
+                    #
+                    # doesn't work :(
+
+                REXML::XPath.first(doc.root, "//link[2]").attribute('href')
+                    #
+                    # will break if the order changes :(
+            end
+    end
+
+    #
+    # A participant that blogs.
+    #
+    #    require 'openwfe/extras/participants/atompub_participants'
+    #    include OpenWFE::Extras
+    #
+    #    target_uri = "https://openwferu.wordpress.com/wp-app.php/posts"
+    #
+    #    params = {}
+    #    params[:username] = 'jeff'
+    #    params[:password] = 'whatever'
+    #    
+    #    params[:categories] = 'openwferu, test'
+    #
+    #    #params[:title_field] = "title"
+    #        #
+    #        # which workitem field will hold the post title ?
+    #        # by default, it's "title"
+    #    
+    #    engine.register_participant "blogger", BlogParticipant.new(target_uri, params) do
+    #        """
+    #            paragraph 0
+    #
+    #            paragraph 1 : ${f:message}
+    #
+    #            paragraph 2
+    #        """
+    #    end
+    #
+    # This participant takes its template and the workitem it receives to
+    # publish a blog entry.
+    #
+    # The template can be specified as a block (as in the previous example)
+    # or via the :template parameter.
+    #
+    class BlogParticipant < AtomPubParticipant
+        include OpenWFE::TemplateMixin
+
+        def initialize (target_uri, params, &block)
+
+            super
+
+            @template = params[:template]
+            @block_template = block
+
+            @content_type = params[:content_type] || "html"
+
+            @title_field = params[:title_field] || "title"
+        end
+
+        protected
+
+            def render_content (entry, workitem)
+
+                entry.title = workitem.attributes[@title_field].to_s
+
+                entry.content = eval_template workitem
+                entry.content["type"] = @content_type
+            end
+    end
+end
+

data/lib/openwfe/extras/participants/csvparticipants.rb

@@ -59,15 +59,11 @@ module Extras
     # An example :
     #     
     #     class TestDefinition0 < ProcessDefinition
-    #         def make
-    #             process_definition :name => "test0", :revision => "0" do
-    #                 sequence do
-    #                     set :field => "weather", :value => "cloudy"
-    #                     set :field => "month", :value => "may"
-    #                     decision
-    #                     _print "${f:take_umbrella?}"
-    #                 end
-    #             end
+    #         sequence do
+    #             set :field => "weather", :value => "cloudy"
+    #             set :field => "month", :value => "may"
+    #             decision
+    #             _print "${f:take_umbrella?}"
     #         end
     #     end
     #     

data/lib/openwfe/extras/util/csvtable.rb

@@ -50,6 +50,63 @@ include OpenWFE
 module OpenWFE
 module Extras
 
+    #
+    # A regexp for checking if a string is a numeric Ruby range
+    #
+    RUBY_NUMERIC_RANGE_REGEXP = Regexp.compile(
+        "^\\d+(\\.\\d+)?\\.{2,3}\\d+(\\.\\d+)?$")
+
+    #
+    # A regexp for checking if a string is an alpha Ruby range
+    #
+    RUBY_ALPHA_RANGE_REGEXP = Regexp.compile(
+        "^([A-Za-z])(\\.{2,3})([A-Za-z])$")
+
+    #
+    # If the string contains a Ruby range definition
+    # (ie something like "93.0..94.5" or "56..72"), it will return
+    # the Range instance.
+    # Will return nil else.
+    #
+    # The Ruby range returned (if any) will accept String or Numeric,
+    # ie (4..6).include?("5") will yield true.
+    #
+    def to_ruby_range (s)
+
+        range = if RUBY_NUMERIC_RANGE_REGEXP.match(s)
+
+            eval s
+        else
+
+            m = RUBY_ALPHA_RANGE_REGEXP.match(s)
+
+            if m
+                eval "'#{m[1]}'#{m[2]}'#{m[3]}'"
+            else
+                nil
+            end
+        end
+
+        class << range
+
+            alias :old_include? :include?
+
+            def include? (elt)
+
+                elt = if first.is_a?(Numeric)
+                    Float(elt)
+                else
+                    elt
+                end
+
+                old_include?(elt)
+            end
+
+        end if range
+
+        range
+    end
+
     #
     # A 'CsvTable' is called a 'decision table' in OpenWFEja (the initial
     # Java implementation of OpenWFE).
@@ -128,6 +185,15 @@ module Extras
     # Such comparisons are done after the elements are transformed to float
     # numbers. By default, non-numeric arguments will get compared as Strings.
     #
+    # Ruby ranges are also accepted in cells. 
+    #
+    #     in:f0,out:result
+    #     ,
+    #     0..32,low
+    #     33..66,medium
+    #     67..100,high
+    #
+    # will set the field 'result' to 'low' for f0 => 24
     #
     # Disclaimer : the decision / CSV table system is no replacement for
     # full rule engines with forward and backward chaining, RETE implementation
@@ -141,21 +207,32 @@ module Extras
     #
     # Currently, two options are supported, "ignorecase" and "through".
     #
-    # "ignorecase", if found by the CsvTable will make any match (in the "in"
-    # columns) case unsensitive.
+    # * "ignorecase", if found by the CsvTable will make any match (in the "in"
+    #   columns) case unsensitive.
+    #
+    # * "through", will make sure that EVERY row is evaluated and potentially
+    #   applied. The default behaviour (without "through"), is to stop the
+    #   evaluation after applying the results of the first matching row.
+    #
+    # * "accumulate", behaves as with "through" set but instead of overriding
+    #   values each time a match is found, will gather them in an array.
     #
-    # "through", will make sure that EVERY row is evaluated and potentially
-    # applied. The default behaviour (without "through"), is to stop the
-    # evaluation after applying the results of the first matching row.
+    #     accumulate
+    #     in:f0,out:result
+    #     ,
+    #     ,normal
+    #     >10,large
+    #     >100,xl
     #
+    #   will yield { result => [ 'normal', 'large' ]} for f0 => 56
     #
     # CSV Tables are available to workflows as CsvParticipant.
     #
     #
     # See also :
     #
-    # http://jmettraux.wordpress.com/2007/02/11/ruby-decision-tables/
-    # http://rubyforge.org/viewvc/trunk/openwfe-ruby/test/extras/csv_test.rb?root=openwferu&view=co
+    # * http://jmettraux.wordpress.com/2007/02/11/ruby-decision-tables/
+    # * http://rubyforge.org/viewvc/trunk/openwfe-ruby/test/extras/csv_test.rb?root=openwferu&view=co
     #
     class CsvTable
 
@@ -163,7 +240,8 @@ module Extras
             :first_match,
             :ignore_case,
             :header,
-            :rows
+            :rows,
+            :accumulate
 
         #
         # The constructor for CsvTable, you can pass a String, an Array 
@@ -174,6 +252,7 @@ module Extras
 
             @first_match = true
             @ignore_case = false
+            @accumulate = false
 
             @header = nil
             @rows = []
@@ -201,7 +280,7 @@ module Extras
             @rows.each do |row|
 
                 if matches?(row, flow_expression, workitem)
-                    apply(row, flow_expression, workitem)
+                    apply row, flow_expression, workitem
                     break if @first_match
                 end
             end
@@ -253,7 +332,7 @@ module Extras
 
             def matches? (row, fexp, wi)
 
-                return false if empty_row? row
+                return false if empty_row?(row)
 
                 #puts
                 #puts "__row match ?"
@@ -279,9 +358,16 @@ module Extras
                     #puts "__does '#{value}' match '#{cell}' ?"
 
                     b = if cell[0, 1] == '<' or cell[0, 1] == '>'
-                        numeric_compare(value, cell)
+
+                        numeric_compare value, cell
                     else
-                        regex_compare(value, cell)
+
+                        range = to_ruby_range cell
+                        if range
+                            range.include?(value)
+                        else
+                            regex_compare value, cell
+                        end
                     end
 
                     return false unless b
@@ -326,16 +412,17 @@ module Extras
                 begin
                     return OpenWFE::eval_safely(s, 4)
                 rescue Exception => e
-                    return false
                 end
+
+                false
             end
 
             def narrow (s)
                 begin
                     return Float(s)
                 rescue Exception => e
-                    return s
                 end
+                s
             end
 
             def resolve_in_header (in_header)
@@ -362,6 +449,7 @@ module Extras
 
                     value = OpenWFE::dosub(value, fexp, wi)
 
+                    #puts "___ value.class:#{value.class}"
                     #puts "___ value:'#{value}'"
                     #puts "___ value:'"+value+"'"
 
@@ -369,6 +457,9 @@ module Extras
 
                     #puts "___ t:'#{type}' target:'#{target}'"
 
+                    value = accumulate_values(type, target, value, wi, fexp) \
+                        if @accumulate
+
                     if type == "v"
                         fexp.set_variable(target, value) if fexp
                     elsif type == "f"
@@ -379,6 +470,42 @@ module Extras
                 end
             end
 
+            #
+            # 'accumulate' is on, this method got called to compute the
+            # new value.
+            #
+            # If it finds nothing in the target field, the new value is
+            # value.
+            # If there is already a value and its an array, the new value
+            # will be current_array + value.
+            # Else the two values (current and new) are combined into an array.
+            #
+            # Sorry, if you want f([ x ], y) -> [[ x ], y]... It's not
+            # implemented like that.
+            #
+            def accumulate_values (type, target, value, workitem, fexp)
+
+                current_value = case type
+                    when 'v'
+                        if fexp
+                            fexp.lookup_variable target
+                        else
+                            nil
+                        end
+                    when 'f'
+                        workitem.lookup_attribute target
+                    when 'r'
+                        nil
+                end
+
+                return value unless current_value
+
+                return current_value + Array(value) \
+                    if current_value.is_a?(Array)
+
+                [ current_value, value ]
+            end
+
             def parse_header_row (row)
 
                 row.each_with_index do |cell, icol|
@@ -398,6 +525,12 @@ module Extras
                         next
                     end
 
+                    if s == "accumulate"
+                        @first_match = false
+                        @accumulate = true
+                        next
+                    end
+
                     if OpenWFE::starts_with(cell, "in:") or OpenWFE::starts_with(cell, "out:")
                         @header = Header.new unless @header
                         @header.add cell, icol

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: openwferu-extras
 version: !ruby/object:Gem::Version 
-  version: 0.9.15
-date: 2007-09-24 00:00:00 +09:00
+  version: 0.9.16
+date: 2007-11-19 00:00:00 +09:00
 summary: OpenWFEru extras (sqs, csv, ...)
 require_paths: 
 - lib
@@ -29,15 +29,23 @@ post_install_message:
 authors: 
 - John Mettraux
 files: 
+- lib/openwfe/extras/engine
+- lib/openwfe/extras/engine/db_persisted_engine.rb
+- lib/openwfe/extras/expool
+- lib/openwfe/extras/expool/dberrorjournal.rb
+- lib/openwfe/extras/expool/dbexpstorage.rb
 - lib/openwfe/extras/listeners
-- lib/openwfe/extras/participants
-- lib/openwfe/extras/util
 - lib/openwfe/extras/listeners/sqslisteners.rb
+- lib/openwfe/extras/misc
+- lib/openwfe/extras/misc/activityfeed.rb
+- lib/openwfe/extras/participants
 - lib/openwfe/extras/participants/activeparticipants.rb
-- lib/openwfe/extras/participants/atomparticipants.rb
+- lib/openwfe/extras/participants/atomfeed_participants.rb
+- lib/openwfe/extras/participants/atompub_participants.rb
 - lib/openwfe/extras/participants/csvparticipants.rb
 - lib/openwfe/extras/participants/sqsparticipants.rb
 - lib/openwfe/extras/participants/twitterparticipants.rb
+- lib/openwfe/extras/util
 - lib/openwfe/extras/util/csvtable.rb
 - lib/openwfe/extras/util/sqs.rb
 test_files: []