openwferu 0.9.16 → 0.9.17

data/lib/openwfe/expressions/raw_xml.rb

@@ -1,176 +0,0 @@
-#
-#--
-# 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.
-#++
-#
-
-#
-# "made in Japan"
-#
-# John Mettraux at openwfe.org
-#
-
-require 'rexml/document'
-
-require 'openwfe/expressions/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
-
-            @raw_representation_s = raw_representation.to_s
-        end
-
-        def raw_representation
-
-            unless @raw_representation
-
-                @raw_representation = \
-                    REXML::Document.new(@raw_representation_s).root
-            end
-
-            @raw_representation
-        end
-
-        protected
-
-            def extract_attributes ()
-                result = {}
-                raw_representation.attributes.each_attribute do |a|
-                    result[a.name] = a.value
-                end
-                return result
-            end
-
-            def extract_descriptions ()
-
-                result = []
-                raw_representation.each_child do |child|
-
-                    next unless child.is_a?(REXML::Element)
-                    next if child.name.intern != :description
-
-                    lang = child.attributes["language"]
-                    lang = child.attributes["lang"] unless lang
-                    lang = "default" unless lang
-
-                    result << [ lang, child.children[0] ]
-                end
-                result
-            end
-
-            def extract_children ()
-
-                c = []
-                i = 0
-
-                raw_representation.each_child do |elt|
-
-                    if elt.kind_of?(REXML::Element)
-
-                        ename = elt.name.intern
-
-                        next if ename == :param
-                        next if ename == :parameter
-                        next if ename == :description
-
-                        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
-
-                c
-            end
-
-            def extract_text_children ()
-
-                raw_representation.children.collect do |elt|
-
-                    next if elt.is_a? REXML::Element
-                    next if elt.is_a? REXML::Comment
-                    s = elt.to_s.strip
-                    next if s.length < 1
-                    s
-                end
-            end
-
-            def extract_parameters ()
-
-                r = []
-                raw_representation.children.each do |child|
-
-                    next unless child.is_a? REXML::Element
-
-                    cname = child.name.intern
-                    next unless (cname == :param or cname == :parameter)
-
-                    r << Parameter.new(
-                        child.attributes["field"],
-                        child.attributes["match"],
-                        child.attributes["default"],
-                        child.attributes["type"])
-                end
-                r
-            end
-    end
-end
-

data/lib/openwfe/expressions/simplerep.rb

@@ -1,266 +0,0 @@
-#
-#--
-# 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 'rexml/document'
-
-require 'openwfe/expressions/raw_prog'
-
-
-module OpenWFE
-
-    #
-    # A raw representation for a process definition, programmatic
-    # process definitions are turned into trees of instances of this class.
-    #
-    # It's just an s-expression somehow.
-    #
-    class SimpleExpRepresentation
-
-        attr_reader \
-            :name, 
-            :attributes
-
-        attr_accessor \
-            :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 raw_expression_class
-
-            ProgRawExpression
-        end
-
-        #
-        # Finds the first child named 'description' and returns its
-        # first child as a String.
-        #
-        # TODO : manage languages, as specified in OpenWFE.
-        #
-        def get_description
-
-            return @children.first.to_s if @name == 'description'
-
-            @children.each do |child|
-                d = child.get_description
-                return d if d
-            end
-
-            nil
-        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)
-
-            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? SimpleExpRepresentation
-                    elt << child.to_xml
-                else
-                    elt << REXML::Text.new(child.to_s)
-                end
-            end
-
-            elt
-        end
-
-        #
-        # Turns an XML tree into a simple representation
-        # (beware embedded XML, should do something to stop that,
-        # CDATA is perhaps sufficient).
-        #
-        def self.from_xml (xml)
-
-            xml = REXML::Document.new(xml) \
-                if xml.is_a?(String)
-
-            xml = xml.root \
-                if xml.is_a?(REXML::Document)
-
-            if xml.is_a?(REXML::Text)
-                #s = xml.to_s
-                #return s if s.strip.length > 1
-                s = xml.to_s.strip
-                return s if s.length > 0
-                return nil
-            end
-
-            # xml element thus...
-
-            name = xml.name
-
-            attributes = {}
-
-            xml.attributes.each do |k, v|
-                attributes[k] = v
-            end
-
-            rep = SimpleExpRepresentation.new(name, attributes)
-
-            xml.children.each do |c|
-                r = from_xml(c)
-                rep << r if r
-            end
-
-            rep
-        end
-
-        #
-        # Evals the given code (string) into a SimpleExpRepresentation.
-        #
-        def self.from_code (code)
-
-            ProcessDefinition.eval_ruby_process_definition code
-        end
-
-        #
-        # Evals the given string a return its SimpleExpRepresentation 
-        # equivalent, ready for evaluation or rendering (fluo).
-        #
-        def self.from_s (s)
-
-            s = s.strip
-
-            if s[0, 1] == "<"
-
-                from_xml s
-            else
-
-                from_code s
-            end
-        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 << ", :#{OpenWFE::to_underscore(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
-
-            s
-        end
-
-        #
-        # Turns this simple representation into an array
-        # (something suitable for to_json()).
-        #
-        def to_a
-
-            cs = @children.collect do |child|
-
-                if child.respond_to?(:to_a)
-
-                    child.to_a
-                else
-
-                    child.to_s
-                end
-            end
-
-            [ @name, @attributes, cs ]
-        end
-    end
-
-end
-

data/lib/openwfe/util/kotoba.rb

@@ -1,236 +0,0 @@
-#
-#--
-# 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
-#
-
-#
-# = Kotoba
-# 
-# This module contains methods for converting plain integers (base 10)
-# into words that are easier to read and remember.
-#
-# For example, the equivalent of the (base 10) integer 1329724967 is
-# "takeshimaya".
-#
-# Kotoba uses 70 of the syllables of the Japanese language, it is thus
-# a base 10 to base 70 converter.
-#
-# Kotoba is meant to be used for generating human readable (or more
-# easily rememberable) identifiers. Its first usage is within the 
-# OpenWFEru Ruby workflow and bpm engine for generating 'kawaii' 
-# business process intance ids.
-#
-# == Kotoba from the command line
-#
-# You can use Kotoba directly from the command line :
-#
-#     $ ruby kotoba.rb kotoba
-#     141260
-#     $ ruby kotoba.rb rubi
-#     3432
-#     $ ruby kotoba.rb 2455
-#     nada
-#
-# might be useful when used from some scripts.
-#
-module Kotoba
-
-    V = %w{ a e i o u }
-    C = %w{ b d g h j k m n p r s t z }
-
-    SYL = []
-
-    C.each do |s|
-        V.each do |v|
-            SYL << s + v
-        end
-    end
-
-    SYL << "wa"
-    SYL << "wo"
-
-    SYL << "ya"
-    SYL << "yo"
-    SYL << "yu"
-
-    SPECIAL = [ 
-        [ "hu", "fu" ],
-        [ "si", "shi" ],
-        [ "ti", "chi" ],
-        [ "tu", "tsu" ],
-        [ "zi", "tzu" ]
-    ]
-
-    #SYL2 = SYL.collect do |syl|
-    #    s = syl
-    #    SPECIAL.each do |a, b|
-    #        if s == a
-    #            s = b
-    #            break
-    #        end
-    #    end
-    #    s
-    #end
-
-    #
-    # Turns the given integer into a Kotoba word.
-    #
-    def Kotoba.from_integer (integer)
-        s = from_i(integer)
-        to_special(s)
-    end
-
-    #
-    # Turns the given Kotoba word to its equivalent integer.
-    # 
-    def Kotoba.to_integer (string)
-        s = from_special(string)
-        to_i(s)
-    end
-
-    #
-    # Turns a simple syllable into the equivalent number.
-    # For example Kotoba::to_number("fu") will yield 19.
-    #
-    def Kotoba.to_number (syllable)
-        SYL.each_with_index do |s, index|
-            return index if syllable == s
-        end
-        raise "did not find syllable '#{syllable}'"
-    end
-
-    #
-    # Given a Kotoba 'word', will split into its list of syllables.
-    # For example, "tsunashima" will be split into 
-    # [ "tsu", "na", "shi", "ma" ]
-    #
-    def Kotoba.split (word)
-        word = from_special(word)
-        a = string_split(word)
-        a_to_special(a)
-    end
-
-    #
-    # Returns if the string is a Kotoba word, like "fugu" or 
-    # "toriyamanobashi".
-    #
-    def Kotoba.is_kotoba_word (string)
-        begin
-            to_integer(string)
-            true
-        rescue #Exception => e
-            false
-        end
-    end
-
-    protected
-
-        def Kotoba.string_split (s, result=[])
-            return result if s.length < 1
-            result << s[0, 2]
-            string_split(s[2..-1], result)
-        end
-
-        def Kotoba.a_to_special (a)
-            a.collect do |syl|
-                SPECIAL.each do |a, b|
-                    if syl == a
-                        syl = b
-                        break
-                    end
-                end
-                syl
-            end
-        end
-
-        def Kotoba.to_special (s)
-            SPECIAL.each do |a, b|
-                s = s.gsub(a, b)
-            end
-            s
-        end
-
-        def Kotoba.from_special (s)
-            SPECIAL.each do |a, b|
-                s = s.gsub(b, a)
-            end
-            s
-        end
-
-        def Kotoba.from_i (integer)
-
-            return '' if integer == 0
-
-            mod = integer % SYL.length
-            rest = integer / SYL.length
-
-            return from_i(rest) + SYL[mod]
-        end
-
-        def Kotoba.to_i (s)
-            return 0 if s.length == 0
-            return SYL.length * to_i(s[0..-3]) + to_number(s[-2, 2])
-        end
-end
-
-#
-# command line interface for Kotoba
-
-if __FILE__ == $0
-    arg = ARGV[0]
-    if arg and arg != "-h" and arg != "--help"
-        begin
-            puts Kotoba::from_integer(Integer(arg))
-        rescue
-            puts Kotoba::to_integer(arg)
-        end
-    else
-        puts
-        puts "ruby #{$0} {arg}"
-        puts
-        puts "  If the arg is a 'Kotoba' word, will turn it into the equivalent"
-        puts "  integer."
-        puts "  Else, it will consider the arg as an integer and attempt at"
-        puts "  turning it into a Kotoba [word]."
-        puts
-        puts "  Kotoba uses #{Kotoba::SYL.length} syllables."
-        puts
-    end
-end
-