ruote 0.9.18

data/lib/openwfe/expressions/fe_filter.rb

@@ -0,0 +1,129 @@
+#
+#--
+# 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 'openwfe/expressions/filter'
+
+
+module OpenWFE
+
+    #
+    # This expression applies a filter to the workitem used by the process
+    # segment nested within it.
+    #
+    #     class TestFilter48a0 < ProcessDefinition
+    #         sequence do
+    #
+    #             set :field => "readable", :value => "bible"
+    #             set :field => "writable", :value => "sand"
+    #             set :field => "randw", :value => "notebook"
+    #             set :field => "hidden", :value => "playboy"
+    #
+    #             alice
+    #
+    #             filter :name => "filter0" do
+    #                 sequence do
+    #                     bob
+    #                     charly
+    #                 end
+    #             end
+    #
+    #             doug
+    #         end
+    #
+    #         filter_definition :name => "filter0" do
+    #             field :regex => "readable", :permissions => "r"
+    #             field :regex => "writable", :permissions => "w"
+    #             field :regex => "randw", :permissions => "rw"
+    #             field :regex => "hidden", :permissions => ""
+    #         end
+    #     end
+    #
+    # In this example, the filter 'filter0' is applied upon entering bob and
+    # charly's sequence.
+    #
+    # Please note that the filter will not be enforced between bob and charly,
+    # it is enforced just before entering the sequence and just after leaving 
+    # it.
+    #
+    # Note also that the ParticipantExpression accepts a 'filter' attribute,
+    # thus :
+    #
+    #     <filter name="filter0">
+    #         <participant ref="toto" />
+    #     </filter>
+    #
+    # can be simplified to :
+    #
+    #     <participant ref="toto" filter="filter0" />
+    #
+    class FilterExpression < FlowExpression
+        include FilterMixin
+
+        names :filter
+
+        attr_accessor :applied_workitem, :filter
+
+
+        def apply workitem
+
+            if @children.length < 1
+                reply_to_parent workitem
+                return
+            end
+
+            @applied_workitem = workitem.dup
+            filter_in workitem, :name
+
+            store_itself
+
+            get_expression_pool.apply @children[0], workitem
+        end
+
+        def reply workitem
+
+            filter_out workitem
+
+            reply_to_parent workitem
+        end
+    end
+
+end
+

data/lib/openwfe/expressions/fe_filter_definition.rb

@@ -0,0 +1,168 @@
+#
+#--
+# 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
+#
+
+require 'openwfe/filterdef'
+
+
+module OpenWFE
+
+    #
+    # This expression binds a filter definition into a variable.
+    #
+    #     class TestFilter48a0 < ProcessDefinition
+    #         sequence do
+    #
+    #             set :field => "readable", :value => "bible"
+    #             set :field => "writable", :value => "sand"
+    #             set :field => "randw", :value => "notebook"
+    #             set :field => "hidden", :value => "playboy"
+    #
+    #             alice
+    #
+    #             filter :name => "filter0" do
+    #                 sequence do
+    #                     bob
+    #                     charly
+    #                 end
+    #             end
+    #
+    #             doug
+    #         end
+    #
+    #         filter_definition :name => "filter0" do
+    #             field :regex => "readable", :permissions => "r"
+    #             field :regex => "writable", :permissions => "w"
+    #             field :regex => "randw", :permissions => "rw"
+    #             field :regex => "hidden", :permissions => ""
+    #         end
+    #     end
+    #
+    # In that example, the filter definition is done for filter 'filter0'.
+    #
+    # A filter definition accepts 4 attributes :
+    #
+    # * 'name' - simply naming the filter, the filter is then bound as a variable. This is the only mandatory attribute.
+    #
+    # * 'closed' - by default, set to 'false'. A closed filter will not allow modifications to unspecified fields.
+    #
+    # * 'add' - by default, set to 'true'. When true, this filter accepts adding new fields to the filtered workitem.
+    #
+    # * 'remove' - by default, set to 'true'. When true, this filter accepts removing fields to the filtered workitem.
+    #
+    #
+    # Inside of the process definition, fields are identified via regular 
+    # expressions ('regex'), a 'permissions' string is then expected with four 
+    # possible values "rw", "w", "r" and "".
+    #
+    class FilterDefinitionExpression < FlowExpression
+
+        is_definition
+
+        names :filter_definition
+
+
+        #
+        # Will build the filter and bind it as a variable.
+        #
+        def apply (workitem)
+
+            filter = build_filter workitem
+            filter_name = lookup_attribute :name, workitem
+
+            set_variable filter_name, filter \
+                if filter_name and filter
+
+            reply_to_parent workitem
+        end
+
+        protected
+
+            #
+            # Builds the filter (as described in the process definition) 
+            # and returns it.
+            #
+            def build_filter (workitem)
+
+                filter = FilterDefinition.new
+
+                # filter attributes
+
+                type = lookup_downcase_attribute :type, workitem
+                closed = lookup_downcase_attribute :closed, workitem
+
+                filter.closed = (type == "closed" or closed == "true")
+
+                add = lookup_downcase_attribute :add, workitem
+                remove = lookup_downcase_attribute :remove, workitem
+
+                filter.add_allowed = (add == "true")
+                filter.remove_allowed = (remove == "true")
+
+                # field by field
+
+                @children.each do |fei|
+
+                    rawexp = get_expression_pool.fetch_expression fei
+                    get_expression_pool.remove fei
+
+                    add_field filter, rawexp, workitem
+                end
+
+                filter
+            end
+
+            #
+            # builds and add a field (a line) of the filter.
+            #
+            def add_field (filter, rawexp, workitem)
+
+                rawexp.load_attributes
+
+                regex = rawexp.lookup_attribute :regex, workitem
+                regex = rawexp.lookup_attribute :name, workitem unless regex
+
+                permissions = 
+                    rawexp.lookup_downcase_attribute :permissions, workitem
+
+                filter.add_field regex, permissions
+            end
+    end
+
+end
+

data/lib/openwfe/expressions/fe_fqv.rb

@@ -0,0 +1,250 @@
+#
+#--
+# 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
+#
+
+require 'json' # gem 'json_pure'
+
+require 'openwfe/util/xml'
+require 'openwfe/expressions/flowexpression'
+
+
+#
+# 'f', 'q' and 'v' expressions
+#
+# 'a' as well
+#
+
+module OpenWFE
+
+    #
+    # This expression implementation gathers the 'f', 'q' and 'v' expressions,
+    # along with their fullname 'field', 'variable' and 'quote'.
+    #
+    # These expressions place the value of the corresponding, field, variable
+    # or quoted (direct value) in the 'result' field of the current workitem.
+    #
+    #     sequence do
+    #
+    #         set :field => "f0", :value => "fox"
+    #         set :variable => "v0", :value => "vixen"
+    #
+    #         set :field => "f1" do
+    #             v "v0"
+    #         end
+    #         set :variable => "v1" do
+    #             f "f0"
+    #         end
+    #         set :variable => "v2" do
+    #             f "f0"
+    #         end
+    #     end
+    #
+    # Well, this is perhaps not the best example.
+    #
+    class FqvExpression < FlowExpression
+
+        names :f, :q, :v, :field, :quote, :variable
+
+        #
+        # apply / reply
+
+        def apply (workitem)
+
+            name = @fei.expression_name[0, 1]
+            text = fetch_text_content workitem
+
+            method = MAP[name]
+
+            result = self.send method, text, workitem
+
+            workitem.set_result(result) if result != nil
+
+            reply_to_parent workitem
+        end
+
+        protected
+
+            MAP = { 
+                "f" => :field, 
+                "q" => :quote, 
+                "v" => :variable 
+            }
+
+            def field (text, workitem)
+                workitem.attributes[text]
+            end
+
+            def quote (text, workitem)
+                text
+            end
+
+            def variable (text, workitem)
+                self.lookup_variable(text)
+            end
+    end
+
+    #
+    # The 'a' or 'attribute' expression. Directly describing some
+    # variable or list content in XML or in YAML.
+    #
+    #     _set :field => "list" do
+    #         _a """
+    #             <array>
+    #                 <string>a</string>
+    #                 <string>b</string>
+    #                 <number>3</number>
+    #                 <string>d</string>
+    #                 <null/>
+    #                 <false/>
+    #                 <string>it's over</string>
+    #             </array>
+    #         """
+    #     end
+    #
+    # or
+    #
+    #     _set :field => "list" do
+    #         _attribute """
+    #     --- 
+    #     - a
+    #     - b
+    #     - c
+    #         """
+    #      end
+    #
+    # Note that it's actually easier to write :
+    #
+    #     _set :field => "list" do
+    #         reval "[ 'a', 'b', 'c' ]"
+    #     end
+    #
+    # but it's less secure. The best way might be :
+    #
+    #     set :field => "list", :value => [ 'a', 'b', 'c' ]
+    #
+    # Yet another way, as this <a> expression accepts JSON :
+    #
+    #     set :field => 'list' do
+    #         a '[1,2,false,"my name"]'
+    #     end
+    #
+    #
+    class AttributeExpression < FlowExpression
+
+        names :a, :attribute
+
+        XML_REGEX = /<.*>/
+
+
+        def apply (workitem)
+
+            child = @children.first
+
+            text = if child.is_a?(String)
+
+                child
+
+            elsif child.is_a?(FlowExpressionId)
+
+                exp = get_expression_pool.fetch_expression child
+                ExpressionTree.to_s exp.raw_representation
+
+            else
+
+                child.to_s
+            end
+
+            text = text.strip
+
+            result = if text[0, 3] == '---'
+
+                from_yaml text
+
+            elsif text.match(XML_REGEX)
+
+                from_xml text
+            end
+
+            result = from_json(text) if result == nil
+
+            workitem.set_result(result) if result != nil
+
+            reply_to_parent workitem
+        end
+
+        protected
+
+            def from_yaml (text)
+
+                begin
+
+                    YAML.load text
+
+                rescue Exception => e
+                    linfo { "from_yaml() failed : #{e}" }
+                    nil
+                end
+            end
+
+            def from_xml (text)
+
+                begin
+
+                    OpenWFE::Xml.from_xml text
+
+                rescue Exception => e
+                    linfo { "from_xml() failed : #{e}" }
+                    nil
+                end
+            end
+
+            def from_json (text)
+
+                begin
+
+                    JSON.parse text
+
+                rescue Exception => e
+                    linfo { "from_json() failed : #{e}" }
+                    nil
+                end
+            end
+    end
+
+end
+