ruote 0.9.18

data/lib/openwfe/tools/flowtracer.rb

@@ -0,0 +1,81 @@
+#
+#--
+# Copyright (c) 2007-2008, 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: workitem.rb 3556 2006-11-13 04:15:52Z jmettraux $
+#
+
+#
+# Made in Japan
+#
+# John Mettraux at OpenWFE dot org
+#
+
+require 'openwfe/workitem'
+require 'openwfe/engine/engine'
+
+#include OpenWFE
+
+
+module OpenWFE
+
+    def trace_flow (process_definition)
+
+        li = LaunchItem.new process_definition
+
+        engine = Engine.new
+
+        i = 0
+
+        engine.register_participant(".*") do |workitem|
+
+            puts "-- #{i} ------------------------------------------------------------------------"
+            puts
+            puts " participant '#{workitem.participant_name}' received workitem :"
+            puts 
+            puts workitem.to_s
+            puts
+            puts "- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -" 
+            puts
+            puts " expression pool state :"
+            #puts 
+            puts engine.get_expression_storage.to_s
+            puts
+            #puts
+
+            i = i + 1
+        end
+
+        engine.launch li
+    end
+
+end
+

data/lib/openwfe/util/dollar.rb

@@ -0,0 +1,217 @@
+#
+#--
+# Copyright (c) 2006-2008, 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
+#
+
+require 'rufus/dollar' # gem 'rufus-dollar'
+require 'rufus/eval' # gem 'rufus-eval'
+
+require 'openwfe/utils'
+
+#
+# 'dollar notation' implementation in Ruby
+#
+
+module OpenWFE
+
+    DSUB_SAFETY_LEVEL = 4
+        #
+        # Ruby code ${ruby:...} will be evaluated with this
+        # safety level.
+        # (see http://www.rubycentral.com/book/taint.html )
+
+    #
+    # Performs 'dollar substitution' on a piece of text with as input
+    # a flow expression and a workitem (fields and variables).
+    #
+    def OpenWFE.dosub (text, flow_expression, workitem)
+
+        #
+        # patch by Nick Petrella (2008/03/20)
+        #
+
+        if text.is_a?(String)
+
+            Rufus::dsub(text, FlowDict.new(flow_expression, workitem))
+
+        elsif text.is_a?(Array)
+
+            text.collect { |e| dosub(e, flow_expression, workitem) }
+
+        elsif text.is_a?(Hash)
+
+            text.inject({}) do |r, (k, v)|
+
+                r[dosub(k, flow_expression, workitem)] = 
+                    dosub(v, flow_expression, workitem)
+                r
+            end
+
+        else
+
+            text
+        end
+    end
+
+    #
+    # Wrapping a process expression and the current workitem as a
+    # Hash object ready for lookup at substitution time.
+    #
+    class FlowDict
+
+        def initialize (flow_expression, workitem, default_prefix='v')
+
+            @flow_expression = flow_expression
+            @workitem = workitem
+            @default_prefix = default_prefix
+        end
+
+        def [] (key)
+
+            pr, k = extract_prefix key
+
+            # stage 0
+
+            v = lookup(pr[0, 1], k)
+            return v if v != nil
+
+            # stage 1
+
+            return "" if pr.size < 2
+
+            lookup(pr[1, 1], k)
+        end
+
+        def []= (key, value)
+
+            pr, k = extract_prefix key
+            pr = pr[0, 1]
+
+            if pr == 'f'
+
+                @workitem.set_attribute k, value
+
+            elsif @flow_expression
+
+                @flow_expression.set_variable k, value
+            end
+        end
+
+        def has_key? (key)
+
+            pr, k = extract_prefix key
+
+            return true if pr == 'r'
+
+            (self[key] != nil)
+        end
+
+        protected
+
+            def lookup (pr, key)
+
+                case pr
+                    when 'v' then @flow_expression.lookup_variable(key)
+                    when 'f' then @workitem.lookup_attribute(key)
+                    when 'r' then call_ruby(key)
+                    else nil
+                end
+            end
+
+            def extract_prefix (key)
+
+                i = key.index(':')
+
+                return [ @default_prefix, key ] if not i
+
+                pr = key[0..i-1] # until ':'
+                pr = pr[0, 2] # the first two chars
+
+                pr = pr[0, 1] unless (pr == 'vf') or (pr == 'fv')
+
+                [ pr, key[i+1..-1] ]
+            end
+
+            #--
+            #def call_function (function_name)
+            #    #"function '#{function_name}' is not implemented"
+            #    "functions are not yet implemented"
+            #        #
+            #        # no need for them... we have Ruby :)
+            #end
+            #++
+
+            #
+            # The ${r:1+2} stuff. ("3").
+            #
+            def call_ruby (ruby_code)
+
+                if @flow_expression
+                    return "" \
+                        if @flow_expression.ac[:ruby_eval_allowed] != true
+                end
+
+                #binding = nil
+                #binding = @flow_expression.get_binding if @flow_expression
+                #eval(ruby_code, binding).to_s
+
+                wi = @workitem
+                workitem = @workitem
+
+                fexp = nil
+                flow_expression = nil
+                fei = nil
+
+                if @flow_expression
+                    fexp = @flow_expression
+                    flow_expression = @flow_expression
+                    fei = @flow_expression.fei
+                end
+                    #
+                    # some simple notations made available to ${ruby:...}
+                    # notations
+
+                #eval(ruby_code, binding).to_s
+                #eval(ruby_code).to_s
+
+                Rufus::eval_safely(
+                    ruby_code, DSUB_SAFETY_LEVEL, binding()).to_s
+            end
+    end
+
+end
+

data/lib/openwfe/util/irb.rb

@@ -0,0 +1,86 @@
+#
+#--
+# 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$
+#
+
+#
+# "made in Japan"
+#
+# John Mettraux at openwfe.org
+#
+
+require 'irb'
+require 'irb/completion'
+
+#
+# borrowing ideas from 
+#
+# http://groups.google.com/group/ruby-talk-google/browse_frm/thread/60ef4f8cff701e14/26ae883a7cc1da7f
+
+
+module OpenWFE
+
+    #
+    # Binds the SIGINT signal so that a console is opened with the bindings
+    # specified in 'args'.
+    #
+    def OpenWFE.trap_int_irb (*args)
+        trap 'INT' do
+            OpenWFE.start_irb_session(*args)
+            #OpenWFE.trap_int_irb(*args) if $openwfe_irb
+            OpenWFE.trap_int_irb(*args)
+        end
+    end
+
+    protected
+
+        def OpenWFE.start_irb_session (*args)
+
+            IRB::setup nil unless $openwfe_irb
+
+            ws = IRB::WorkSpace.new *args
+
+            $openwfe_irb = IRB::Irb.new ws
+
+            IRB::conf[:MAIN_CONTEXT] = $openwfe_irb.context
+
+            trap 'INT' do
+                $openwfe_irb.signal_handle
+            end
+
+            $openwfe_irb.eval_input
+
+            puts "\nbye!"
+        end
+end
+

data/lib/openwfe/util/observable.rb

@@ -0,0 +1,144 @@
+#
+#--
+# Copyright (c) 2007-2008, 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
+#
+
+module OpenWFE
+
+    #
+    # A classic : this mixin gathers observability methods. It assumes
+    # that customer classes will have a @observers instance variable
+    # available.
+    # This mixin is chiefly used by the ExpressionPool class.
+    #
+    module OwfeObservable
+
+        #
+        # Observers will register themselves to the Observable via
+        # this method.
+        #
+        # An observer is an instance which responds to call(channel, *args)
+        #
+        # Returns the observer object (or the block's Proc object), could
+        # be useful when removing the observer.
+        #
+        def add_observer (channel, observer=nil, &callback)
+
+            observer = callback unless observer
+            (@observers[channel] ||= []) << observer
+            observer
+        end
+
+        #
+        # Removes an observer (this obviously doesn't work well when 
+        # the actual observer is a block).
+        # If a channel is given, the observer will only get removed when
+        # registered for that channel.
+        #
+        def remove_observer (observer, channel=nil)
+
+            channels = if channel
+                [ channel ]
+            else
+                @observers.keys
+            end
+
+            channels.each do |c|
+                do_remove_observer observer, c
+            end
+        end
+
+        protected
+
+            #
+            # Observable classes do call this method to notify their
+            # observers.
+            #
+            # Returns true if there was an observer registered.
+            #
+            def onotify (channel, *args)
+
+                do_notify(:all, channel, *args)
+                do_notify(channel, channel, *args)
+            end
+
+        private
+
+            def do_remove_observer (observer, channel)
+
+                observers = @observers[channel]
+                observers.delete(observer) if observers
+            end
+
+            def do_notify (target_channel, channel, *args)
+
+                #ldebug { "do_notify() @observers.size is #{@observers.size}" }
+
+                if target_channel.is_a?(String)
+
+                    observers = []
+
+                    @observers.each do |c, o|
+
+                        if c.is_a?(String)
+                            next unless target_channel.match(c)
+                        elsif c.is_a?(Regexp)
+                            next unless c.match(target_channel)
+                        else
+                            next
+                        end
+
+                        observers = observers + o
+                    end
+                else
+
+                    observers = @observers[target_channel]
+                end
+
+                return false unless observers
+
+                observers.each do |obs|
+                    obs.call channel, *args
+                end
+
+                (observers.size > 0)
+                    #
+                    # returns true if at least one observer was called
+            end
+    end
+end
+