openwferu 0.9.1 → 0.9.2

data/lib/openwfe/expressions/raw_prog.rb

@@ -0,0 +1,391 @@
+#
+#--
+# 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
+#
+
+require 'rexml/document'
+
+require 'openwfe/expressions/fe_raw'
+require 'openwfe/expressions/fe_utils'
+
+
+module OpenWFE
+
+    #
+    # A raw representation for a process definition, programmatic
+    # process definitions are turned into trees of instances of this class.
+    #
+    class ProgExpRepresentation
+
+        attr_reader \
+            :name, 
+            :attributes,
+            :children
+
+        def initialize (name, attributes)
+            super()
+            @name = name
+            @attributes = attributes
+            @children = []
+        end
+
+        #
+        # Adds a child to this expression representation.
+        #
+        def << (child)
+            @children << child
+        end
+
+        #
+        # Always return the ProgRawExpression class.
+        #
+        def rawExpressionClass
+            return ProgRawExpression
+        end
+
+        #
+        # Returns an XML string, containing the equivalent process definition
+        # in the classical OpenWFE process definition language.
+        #
+        def to_s
+            doc = REXML::Document.new()
+            doc << to_xml
+            s = ""
+            doc.write(s, 0)
+            return s
+        end
+
+        #
+        # Returns this representation tree as an XML element (and its children).
+        #
+        def to_xml
+
+            elt = REXML::Element.new(@name)
+
+            #elt.attributes.update(@attributes)
+            @attributes.each do |k, v|
+                elt.attributes[k] = v
+            end
+
+            @children.each do |child|
+                if child.kind_of? ProgExpRepresentation
+                    elt << child.to_xml
+                else
+                    elt << REXML::Text.new(child.to_s)
+                end
+            end
+
+            return elt
+        end
+
+        #
+        # Returns a string containing the ruby code that generated this
+        # raw representation tree.
+        #
+        def to_code_s (indentation = 0)
+
+            s = ""
+            tab = "    "
+            ind = tab * indentation
+
+            s << ind
+            s << OpenWFE.make_safe(@name)
+
+            sa = ""
+            @attributes.each do |k, v|
+                sa << ", :#{k} => '#{v}'"
+            end
+            s << sa[1..-1] if sa.length > 0
+
+            if @children.length > 0
+                s << " do\n"
+                @children.each do |child|
+                    if child.respond_to? :to_code_s
+                        s << child.to_code_s(indentation + 1)
+                    else
+                        s << ind
+                        s << tab
+                        s << "'#{child.to_s}'"
+                    end
+                    s << "\n"
+                end
+                s << ind
+                s << "end"
+            end
+
+            return s
+        end
+    end
+
+    #
+    # This is the class to extend to create a programmatic process definition.
+    #
+    # A short example :
+    # <tt>
+    # class MyProcessDefinition < OpenWFE::ProcessDefinition
+    #     def make
+    #         process_definition :name => "test1", :revision => "0" do
+    #             sequence do
+    #                 set :variable => "toto", :value => "nada"
+    #                 print "toto:${toto}"
+    #             end
+    #         end
+    #     end
+    # end
+    #
+    # li = OpenWFE::LaunchItem.new(MyProcessDefinition)
+    # engine.launch(li)
+    # </tt>
+    #
+    class ProcessDefinition
+
+        def initialize (exp_names=nil)
+
+            super()
+
+            if not exp_names
+                exp_names = $EXPRESSION_NAMES if $EXPRESSION_NAMES
+            else
+                if exp_names.kind_of? ExpressionMap
+                    exp_names = exp_names.expression_names
+                elsif exp_names.kind_of? Engine
+                    exp_names = exp_names.get_expression_map.expression_names
+                elsif exp_names.kind_of? Hash
+                    exp_names = exp_names[S_EXPRESSION_MAP].expression_names
+                elsif not exp_names.kind_of? Array
+                    exp_names = $EXPRESSION_NAMES
+                end
+            end
+
+            if not exp_names
+                raise "no expression names found, please provide them"
+            end
+
+            @exp_names = exp_names
+
+            #exp_names.each do |exp_name|
+            #    register_expression(exp_name)
+            #end
+
+            @previous_parent_expression = []
+        end
+
+        #
+        # previous trick
+        #
+        # kept for the record.
+        #
+        #def register_expression (expression_name)
+        #    _exp_name = OpenWFE.make_safe(exp_name)
+        #    self.instance_eval """
+        #        def #{_exp_name} (params={}, &block)
+        #            make_expression('#{exp_name}', params, &block)
+        #        end
+        #    """
+        #end
+
+        def method_missing (m, *args, &block)
+
+            methodname = m.to_s
+
+            expname = OpenWFE.to_expression_name(methodname)
+            if not @exp_names.include? expname
+                #raise "No expression named '#{methodname}' (#{expname}) found"
+                #raise "No expression named '#{expname}' found"
+                params = args[0]
+                params = {} if not params
+                params["ref"] = methodname
+                return make_expression("subprocess", params, &block)
+            end
+            make_expression(expname, args[0], &block)
+        end
+
+        #
+        # This method has to be overriden in order to define
+        # a process definition.
+        #
+        def make
+            raise "make() implementation is missing, please provide one"
+        end
+
+        def make_expression (exp_name, params, &block)
+
+            exp_name = exp_name.to_s
+
+            string_child = nil
+            attributes = {}
+
+            #puts " ... params.class is #{params.class}"
+
+            if params.kind_of? Hash 
+                params.each do |k, v|
+                    #attributes[k.to_s] = v.to_s
+                    attributes[OpenWFE.to_dash(k.to_s)] = v.to_s
+                end
+            elsif params
+                string_child = params.to_s
+            end
+
+            exp = ProgExpRepresentation.new(exp_name, attributes)
+
+            exp.children << string_child \
+                if string_child
+
+            @parent_expression << exp \
+                if @parent_expression
+
+            return exp if not block
+
+            @previous_parent_expression.push(@parent_expression) \
+                if @parent_expression
+
+            @parent_expression = exp
+
+            result = block.call
+            #if result and result.kind_of? String and result.length > 0
+            #    puts " ... child is >#{result}<"
+            #    exp.children << result
+            #end
+            #exp.children << result \
+            #    if result and not result.kind_of? ProgExpRepresentation
+            exp.children << result \
+                if result and result.kind_of? String
+
+            @parent_expression = @previous_parent_expression.pop
+
+            return exp
+        end
+
+        #
+        # A class method for actually "making" the process 
+        # segment raw representation
+        #
+        def ProcessDefinition.do_make (exp_names=nil)
+            self.new(exp_names).make
+        end
+    end
+
+    #
+    # The actual 'programmatic' raw expression.
+    # Its raw_representation being an instance of ProgExpRepresentation.
+    #
+    class ProgRawExpression < RawExpression
+
+        attr_accessor \
+            :raw_representation
+
+        def initialize \
+            (fei, parent_id, env_id, application_context, raw_representation)
+
+            super(
+                fei, 
+                parent_id, 
+                env_id, 
+                application_context, 
+                raw_representation)
+        end
+
+        protected 
+
+            def extract_attributes ()
+                return raw_representation.attributes
+            end
+
+            def extract_children ()
+
+                i = 0
+                raw_representation.children.collect do |child|
+
+                    if child.kind_of? ProgExpRepresentation
+
+                        cfei = @fei.dup
+                        cfei.expression_name = child.name
+                        cfei.expression_id = "#{cfei.expression_id}.#{i}"
+
+                        efei = @environment_id
+
+                        rawexp = ProgRawExpression\
+                            .new(cfei, @fei, efei, @application_context, child)
+
+                        get_expression_pool.update(rawexp)
+
+                        i = i + 1
+
+                        rawexp.fei
+                    else
+
+                        child
+                    end
+                end
+            end
+    end
+
+    private
+
+        #
+        # OpenWFE process definitions do use some
+        # Ruby keywords... The workaround is to put an underscore
+        # just before the name to 'escape' it.
+        #
+        # 'undo' isn't reserved by Ruby, but lets keep it in line
+        # with 'do' and 'redo' that are.
+        #
+        KEYWORDS = [
+            :if, :do, :redo, :undo, :print
+        ]
+
+        #
+        # Ensures the method name is not conflicting with Ruby keywords
+        # and turn dashes to underscores.
+        #
+        def OpenWFE.make_safe (method_name)
+            method_name = to_underscore(method_name)
+            return "_" + method_name \
+                if KEYWORDS.include? eval(":"+method_name)
+            return method_name
+        end
+
+        def OpenWFE.to_expression_name (method_name)
+            method_name = method_name[1..-1] if method_name[0, 1] == "_"
+            method_name = to_dash(method_name)
+            return method_name
+        end
+
+end
+

data/lib/openwfe/expressions/raw_xml.rb

@@ -0,0 +1,128 @@
+#
+#--
+# Copyright (c) 2006-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
+#
+
+require 'rexml/document'
+
+require 'openwfe/expressions/fe_raw'
+
+
+module OpenWFE
+
+    #
+    # Handling process definition whose representation is in XML
+    # (the classical OpenWFE case).
+    #
+    class XmlRawExpression < RawExpression
+
+        def initialize \
+            (fei, parent_id, env_id, application_context, raw_representation)
+
+            super(
+                fei, 
+                parent_id, 
+                env_id, 
+                application_context, 
+                raw_representation)
+
+            @raw_representation_s = raw_representation.to_s
+        end
+
+        def raw_representation
+            synchronize do
+                if not @raw_representation
+                    @raw_representation = \
+                        REXML::Document.new(@raw_representation_s).root
+                end
+                return @raw_representation
+            end
+        end
+
+        protected
+
+            def extract_attributes ()
+                result = {}
+                raw_representation.attributes.each_attribute do |a|
+                    result[a.name] = a.value
+                end
+                return result
+            end
+
+            def extract_children ()
+
+                c = []
+                i = 0
+
+                raw_representation.each_child do |elt|
+
+                    if elt.kind_of?(REXML::Element)
+
+                        cfei = @fei.dup
+
+                        efei = @environment_id
+
+                        cfei.expression_name = elt.name
+                        cfei.expression_id = "#{cfei.expression_id}.#{i}"
+
+                        rawchild = XmlRawExpression\
+                            .new(cfei, @fei, efei, @application_context, elt)
+
+                        get_expression_pool().update(rawchild)
+                        c << rawchild.fei
+
+                        i = i+1
+
+                    elsif elt.kind_of?(REXML::Comment)
+
+                        next
+
+                    else
+
+                        s = elt.to_s.strip
+                        c << s if s.length > 0
+
+                    end
+                end
+
+                return c
+            end
+    end
+end
+