lib/openwfe/expressions/raw.rb in openwferu-0.9.16 vs lib/openwfe/expressions/raw.rb in openwferu-0.9.17
- old
+ new
@@ -1,8 +1,8 @@
#
#--
-# Copyright (c) 2006-2007, John Mettraux, OpenWFE.org
+# 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:
#
@@ -43,60 +43,83 @@
module OpenWFE
#
- # An 'abstract' class storing bits (trees) of process definitions just
+ # A class storing bits (trees) of process definitions just
# parsed. Upon application (apply()) these raw expressions get turned
# into real expressions.
- # The first and classical extension of this class is XmlRawExpression.
#
class RawExpression < FlowExpression
- def initialize (
- fei, parent_id, env_id, application_context, raw_representation)
- super(fei, parent_id, env_id, application_context, nil)
+ def self.new_raw (
+ fei, parent_id, env_id, app_context, raw_representation)
- #linfo { "initialize() '#{fei.expression_name}'" }
+ re = self.new
- @raw_representation = raw_representation
+ re.fei = fei
+ re.parent_id = parent_id
+ re.environment_id = env_id
+ re.application_context = app_context
+ re.attributes = nil
+ re.children = []
+ re.apply_time = nil
- #new_environment() if not @environment_id
- #
- # now done in the launch methods of the expression pool
+ re.raw_representation = raw_representation
+ re
end
+ #--
+ # a duplication method that duplicates everything, except
+ # the application context
+ #
+ #def dup
+ # self.class.new_raw(
+ # @fei.dup,
+ # @parent_id ? @parent_id.dup : nil,
+ # @environment_id ? @environment_id.dup : nil,
+ # @application_context,
+ # raw_representation)
+ #end
+ #alias :fulldup :dup
+ #++
+
def instantiate_real_expression (
workitem, exp_name=nil, exp_class=nil, attributes=nil)
- exp_name = expression_name() unless exp_name
- exp_class = expression_class() unless exp_class
+ exp_name ||= expression_name
+ exp_class ||= expression_class
raise "unknown expression '#{exp_name}'" \
unless exp_class
#ldebug do
# "instantiate_real_expression() exp_class is #{exp_class}"
#end
- attributes = extract_attributes() unless attributes
+ attributes ||= raw_representation[1]
- expression = exp_class.new(
- @fei,
- @parent_id,
- @environment_id,
- @application_context,
- attributes)
+ exp = exp_class.new
+ exp.fei = @fei
+ exp.parent_id = @parent_id
+ exp.environment_id = @environment_id
+ exp.application_context = @application_context
+ exp.attributes = attributes
- consider_tag(workitem, expression)
+ exp.raw_representation = raw_representation
+ #
+ # keeping track of how the expression look at apply /
+ # instantiation time
+
+ consider_tag workitem, exp
- handle_descriptions()
+ handle_descriptions
- expression.children = extract_children()
+ exp.children = extract_children
- expression
+ exp
end
#
# When a raw expression is applied, it gets turned into the
# real expression which then gets applied.
@@ -125,38 +148,55 @@
extract_parameters.each do |param|
param.check(workitem)
end
end
+ #--
#def reply (workitem)
# no implementation necessary
#end
+ #++
- def is_definition? ()
+ def is_definition?
+
get_expression_map.is_definition?(expression_name())
end
- def expression_class ()
+ def expression_class
+
get_expression_map.get_class(expression_name())
end
- def definition_name ()
- raw_representation.attributes['name'].to_s
+ def definition_name
+
+ raw_representation[1]['name'].to_s
end
- def expression_name ()
- raw_representation.name
+ def expression_name
+
+ raw_representation.first
end
#
# Forces the raw expression to load the attributes and set them
# in its @attributes instance variable.
# Currently only used by FilterDefinitionExpression.
#
def load_attributes
- @attributes = extract_attributes()
+
+ @attributes = raw_representation[1]
end
+
+ #
+ # This method has been made public in order to have quick look
+ # at the attributes of an expression before it's really
+ # 'instantiated'.
+ #
+ def extract_attributes
+
+ raw_representation[1]
+ end
protected
#
# looks up a participant in the participant map, considers
@@ -170,39 +210,42 @@
unless p
name = OpenWFE::to_underscore(name)
p = get_participant_map.lookup_participant(name)
end
- if p
- name
- else
- nil
- end
+ return name if p
+
+ nil
end
#
# Determines if this raw expression points to a classical
# expression, a participant or a subprocess, or nothing at all...
#
- def determine_real_expression ()
+ def determine_real_expression
exp_name = expression_name()
-
exp_class = expression_class()
- attributes = nil
+ var_value = lookup_variable exp_name
+ attributes = extract_attributes
- var_value = lookup_variable(exp_name)
+ unless var_value
+ #
+ # accomodating "sub_process_name" and "sub-process-name"
+ #
+ alt = OpenWFE::to_underscore exp_name
+ var_value = lookup_variable(alt) if alt != exp_name
- var_value = exp_name if (not exp_class and not var_value)
-
- if var_value
- attributes = extract_attributes()
+ exp_name = alt if var_value
end
+ var_value = exp_name \
+ if (not exp_class and not var_value)
+
if var_value.is_a?(String)
- participant_name = lookup_participant(var_value)
+ participant_name = lookup_participant var_value
if participant_name
exp_name = participant_name
exp_class = ParticipantExpression
attributes['ref'] = participant_name
@@ -243,28 +286,98 @@
set_variable "description", ds[0][1].to_s \
unless default
end
- #--
- #def extract_attributes ()
- # raise NotImplementedError.new("'abstract method' sorry")
- #end
- #def extract_children ()
- # raise NotImplementedError.new("'abstract method' sorry")
- #end
- #def extract_descriptions ()
- # raise NotImplementedError.new("'abstract method' sorry")
- #end
- #def extract_parameters ()
- # raise NotImplementedError.new("'abstract method' sorry")
- #end
- #def extract_text_children ()
- # raise NotImplementedError.new("'abstract method' sorry")
- #end
- #++
+ def extract_descriptions
+ result = []
+ raw_representation.last.each do |child|
+
+ #next unless child.is_a?(SimpleExpRepresentation)
+ next if is_not_a_node?(child)
+ next if child.first.intern != :description
+
+ attributes = child[1]
+
+ lang = attributes[:language]
+ lang = attributes[:lang] unless lang
+ lang = "default" unless lang
+
+ result << [ lang, child.last.first ]
+ end
+ result
+ end
+
+ def extract_children
+
+ i = 0
+ result = []
+ raw_representation.last.each do |child|
+
+ #if child.kind_of?(SimpleExpRepresentation)
+ #if child.kind_of?(Array)
+ if is_not_a_node?(child)
+
+ result << child
+ else
+
+ cname = child.first.intern
+
+ next if cname == :param
+ next if cname == :parameter
+ next if cname == :description
+
+ cfei = @fei.dup
+ cfei.expression_name = child.first
+ cfei.expression_id = "#{cfei.expression_id}.#{i}"
+
+ efei = @environment_id
+
+ rawexp = RawExpression.new_raw(
+ cfei, @fei, efei, @application_context, child)
+
+ get_expression_pool.update rawexp
+
+ i = i + 1
+
+ result << rawexp.fei
+ end
+ end
+ result
+ end
+
+ def extract_parameters
+
+ r = []
+ raw_representation.last.each do |child|
+
+ #next unless child.is_a?(SimpleExpRepresentation)
+ #next unless child.is_a?(Array)
+ next if is_not_a_node?(child)
+
+ name = child.first.to_sym
+ next unless (name == :parameter or name == :param)
+
+ attributes = child[1]
+
+ r << Parameter.new(
+ attributes['field'],
+ attributes['match'],
+ attributes['default'],
+ attributes['type'])
+ end
+ r
+ end
+
+ def is_not_a_node? (child)
+
+ (( ! child.is_a?(Array)) ||
+ child.size != 3 ||
+ ( ! child.first.is_a?(String)))
+ end
+
#
# Expressions can get tagged. Tagged expressions can easily
# be cancelled (undone) or redone.
#
def consider_tag (workitem, new_expression)
@@ -273,11 +386,11 @@
return unless tagname
ldebug { "consider_tag() tag is '#{tagname}'" }
- set_variable(tagname, Tag.new(self, workitem))
+ set_variable tagname, Tag.new(self, workitem)
#
# keep copy of raw expression and workitem as applied
new_expression.attributes["tag"] = tagname
#
@@ -308,10 +421,13 @@
#
# Encapsulating
# <parameter field="x" default="y" type="z" match="m" />
#
+ # Somehow I have that : OpenWFEru is not a strongly typed language
+ # ... Anyway I implemented that to please Pat.
+ #
class Parameter
def initialize (field, match, default, type)
@field = to_s field
@@ -388,8 +504,90 @@
"value of field '#{@field}' doesn't match"
end
end
end
end
+
+ #
+ # This class is only present to ensure that OpenWFEru 0.9.17 can read
+ # previous (<= 0.9.16) expools.
+ #
+ class ProgRawExpression < RawExpression
+
+ def raw_representation
+
+ @raw_representation.to_a
+ end
+ end
+
+ #
+ # This class is only present to ensure that OpenWFEru 0.9.17 can read
+ # previous (<= 0.9.16) expools.
+ #
+ class XmlRawExpression < RawExpression
+
+ def raw_representation
+
+ #SimpleExpRepresentation.from_xml @raw_representation_s
+ DefParser.parse_xml @raw_representation_s
+ end
+ end
+
+ #
+ # This class is only present to ensure that OpenWFEru 0.9.17 can read
+ # previous (<= 0.9.16) expools.
+ #
+ class SimpleExpRepresentation
+
+ def to_a
+
+ children = @children.collect do |c|
+ if c.is_a?(SimpleExpRepresentation)
+ c.to_a
+ else
+ c
+ end
+ end
+
+ a = [ @name, @attributes, children ]
+ 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, :sleep, :loop, :break, :when
+ #:until, :while
+ ]
+
+ #
+ # Ensures the method name is not conflicting with Ruby keywords
+ # and turn dashes to underscores.
+ #
+ def OpenWFE.make_safe (method_name)
+
+ method_name = OpenWFE::to_underscore(method_name)
+
+ return "_" + method_name \
+ if KEYWORDS.include? eval(":"+method_name)
+
+ method_name
+ end
+
+ def OpenWFE.to_expression_name (method_name)
+
+ method_name = method_name.to_s
+ method_name = method_name[1..-1] if method_name[0, 1] == "_"
+ method_name = OpenWFE::to_dash(method_name)
+ method_name
+ end
end