xmlutils 0.0.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +7 -0
- data/.gitignore +6 -0
- data/Gemfile +4 -0
- data/LICENSE +22 -0
- data/README.md +77 -0
- data/bin/xmltogdl +88 -0
- data/docs/README.txt +20 -0
- data/lib/xmlutils/contextlistener.rb +432 -0
- data/lib/xmlutils/contextparser.rb +111 -0
- data/lib/xmlutils/dumplistener.rb +57 -0
- data/lib/xmlutils/gdlcontext.rb +305 -0
- data/lib/xmlutils/gdlcontextobjs.rb +286 -0
- data/lib/xmlutils/gdldoc.rb +547 -0
- data/lib/xmlutils/gdldocbuilder.rb +181 -0
- data/lib/xmlutils/gdllistener.rb +265 -0
- data/lib/xmlutils/gdltemplate.rb +488 -0
- data/lib/xmlutils/lineparser.rb +193 -0
- data/lib/xmlutils/listener.rb +459 -0
- data/lib/xmlutils/rulelistener.rb +414 -0
- data/lib/xmlutils/ruleparser.rb +112 -0
- data/lib/xmlutils/varlistener.rb +86 -0
- data/lib/xmlutils/version.rb +5 -0
- data/lib/xmlutils/xmlrulevisitor.rb +704 -0
- data/lib/xmlutils/xmltogdlcontroller.rb +93 -0
- data/lib/xmlutils/xmltogdltask.rb +23 -0
- data/lib/xmlutils/xmlvisitor.rb +690 -0
- data/lib/xmlutils.rb +40 -0
- data/rakefile.rb +34 -0
- data/unittests/2830.xml +1 -0
- data/unittests/chunks.rb +31 -0
- data/unittests/curDirTest.rb +2 -0
- data/unittests/data/2830-GENERATED.gdl +309 -0
- data/unittests/data/2830-GENERATED.xml +1 -0
- data/unittests/data/AUGuideline.xml +12 -0
- data/unittests/data/AUGuideline.xml.gdl +19190 -0
- data/unittests/data/BAKUP.DCTEST1.xml +1 -0
- data/unittests/data/DCTEST.xml +1 -0
- data/unittests/data/DCTEST1.xml +1 -0
- data/unittests/data/DCTEST1.xml.gdl +14890 -0
- data/unittests/data/DCTEST1.xml.rename.csv +180 -0
- data/unittests/data/DCTEST1wLookups.xml +174 -0
- data/unittests/data/DCTEST1wLookups.xml.gdl +127 -0
- data/unittests/data/GENERATED.gdl.xml +1 -0
- data/unittests/data/Message.xml +1 -0
- data/unittests/data/Message.xml.gdl +142 -0
- data/unittests/data/Pricing2ndGuideline.xml +1 -0
- data/unittests/data/Pricing2ndGuideline.xml.gdl +52670 -0
- data/unittests/data/Z-TEMP-Jeff.xml +1 -0
- data/unittests/data/Z-TEMP-Jeff.xml.gdl +288 -0
- data/unittests/tc_convert_xml_to_gdl.rb +23 -0
- data/unittests/ts_allTests.rb +2 -0
- data/xmlutils.gemspec +25 -0
- metadata +139 -0
@@ -0,0 +1,414 @@
|
|
1
|
+
#
|
2
|
+
# File: ruleListener.rb
|
3
|
+
#
|
4
|
+
# This class is an rule listener base class
|
5
|
+
#
|
6
|
+
#
|
7
|
+
|
8
|
+
require 'rexml/streamlistener'
|
9
|
+
|
10
|
+
include REXML
|
11
|
+
|
12
|
+
|
13
|
+
|
14
|
+
|
15
|
+
#################################################
|
16
|
+
#
|
17
|
+
# class RuleListener
|
18
|
+
#
|
19
|
+
#################################################
|
20
|
+
class RuleListener
|
21
|
+
include StreamListener
|
22
|
+
|
23
|
+
attr_writer :verbose
|
24
|
+
|
25
|
+
attr_writer :inRule
|
26
|
+
attr_writer :inIfMsgs
|
27
|
+
attr_writer :inElseMsgs
|
28
|
+
attr_writer :inMsg
|
29
|
+
|
30
|
+
attr_accessor :curRuleName
|
31
|
+
attr_accessor :curRuleSrc
|
32
|
+
attr_accessor :curIfMsgs
|
33
|
+
attr_accessor :curElseMsgs
|
34
|
+
attr_accessor :context
|
35
|
+
|
36
|
+
|
37
|
+
|
38
|
+
def inRule?
|
39
|
+
@inRule
|
40
|
+
end
|
41
|
+
|
42
|
+
|
43
|
+
|
44
|
+
|
45
|
+
def inIfMsgs?
|
46
|
+
@inIfMsgs
|
47
|
+
end
|
48
|
+
|
49
|
+
|
50
|
+
|
51
|
+
|
52
|
+
def inElseMsgs?
|
53
|
+
@inElseMsgs
|
54
|
+
end
|
55
|
+
|
56
|
+
|
57
|
+
|
58
|
+
|
59
|
+
def inMsg?
|
60
|
+
@inMsg
|
61
|
+
end
|
62
|
+
|
63
|
+
|
64
|
+
|
65
|
+
|
66
|
+
def verbose?
|
67
|
+
@verbose
|
68
|
+
end
|
69
|
+
|
70
|
+
|
71
|
+
|
72
|
+
|
73
|
+
#-------------------------------------------------------------------------------------------------------------#
|
74
|
+
# initialize - Ctor
|
75
|
+
#
|
76
|
+
#
|
77
|
+
#------------------------------------------------------------------------------------------------------------#
|
78
|
+
def initialize(ctx)
|
79
|
+
super()
|
80
|
+
|
81
|
+
@inRule = false
|
82
|
+
@inIfMsgs = false
|
83
|
+
@inElseMsgs = false
|
84
|
+
@inMsg = false
|
85
|
+
|
86
|
+
@curRuleSrc = ""
|
87
|
+
@curRuleName = nil
|
88
|
+
@curIfMsgs = Array.new
|
89
|
+
@curElseMsgs = Array.new
|
90
|
+
|
91
|
+
@context = ctx
|
92
|
+
end
|
93
|
+
|
94
|
+
|
95
|
+
|
96
|
+
#-------------------------------------------------------------------------------------------------------------#
|
97
|
+
# tag_start - A start tag has been parsed
|
98
|
+
#
|
99
|
+
# tag - name of tag (element name)
|
100
|
+
# attributes - element tag attributes
|
101
|
+
#------------------------------------------------------------------------------------------------------------#
|
102
|
+
def tag_start(tag, attributes)
|
103
|
+
case tag
|
104
|
+
when 'Rule'
|
105
|
+
openRule(attributes)
|
106
|
+
|
107
|
+
when 'IfMessages'
|
108
|
+
@inIfMsgs = true
|
109
|
+
openUnknown(tag, attributes)
|
110
|
+
|
111
|
+
when 'ElseMessages'
|
112
|
+
@inElseMsgs = true
|
113
|
+
openUnknown(tag, attributes)
|
114
|
+
|
115
|
+
when 'Message'
|
116
|
+
openMessage(attributes)
|
117
|
+
|
118
|
+
else
|
119
|
+
openUnknown(tag, attributes)
|
120
|
+
end # case
|
121
|
+
|
122
|
+
end
|
123
|
+
|
124
|
+
|
125
|
+
|
126
|
+
|
127
|
+
#-------------------------------------------------------------------------------------------------------------#
|
128
|
+
# tag_end - An ending tag has been parsed
|
129
|
+
#
|
130
|
+
# tag - name of tag (element name)
|
131
|
+
#------------------------------------------------------------------------------------------------------------#
|
132
|
+
def tag_end(tag)
|
133
|
+
|
134
|
+
case tag
|
135
|
+
when 'Rule'
|
136
|
+
closeRule()
|
137
|
+
|
138
|
+
when 'IfMessages'
|
139
|
+
@inIfMsgs = false
|
140
|
+
closeUnknown(tag)
|
141
|
+
|
142
|
+
when 'ElseMessages'
|
143
|
+
@inElseMsgs = false
|
144
|
+
closeUnknown(tag)
|
145
|
+
|
146
|
+
|
147
|
+
when 'Message'
|
148
|
+
closeMessage()
|
149
|
+
|
150
|
+
else
|
151
|
+
closeUnknown(tag)
|
152
|
+
end # case
|
153
|
+
|
154
|
+
end
|
155
|
+
|
156
|
+
|
157
|
+
|
158
|
+
|
159
|
+
#-------------------------------------------------------------------------------------------------------------#
|
160
|
+
# addMsg - Add a message to the proper message list
|
161
|
+
#
|
162
|
+
# msg - msg to add
|
163
|
+
#------------------------------------------------------------------------------------------------------------#
|
164
|
+
def addMsg(msg)
|
165
|
+
puts "addMsg: #{msg}" if $DEBUG
|
166
|
+
|
167
|
+
if (inIfMsgs?)
|
168
|
+
@curIfMsgs << msg
|
169
|
+
elsif (inElseMsgs?)
|
170
|
+
@curElseMsgs << msg
|
171
|
+
end
|
172
|
+
end
|
173
|
+
|
174
|
+
|
175
|
+
|
176
|
+
|
177
|
+
#-------------------------------------------------------------------------------------------------------------#
|
178
|
+
# entity - An entity has been parsed
|
179
|
+
#
|
180
|
+
# content - entity content
|
181
|
+
#------------------------------------------------------------------------------------------------------------#
|
182
|
+
def entity(content)
|
183
|
+
puts "entity: #{content}" if $DEBUG
|
184
|
+
|
185
|
+
if (inRule?)
|
186
|
+
@curRuleSrc += content
|
187
|
+
end
|
188
|
+
end
|
189
|
+
|
190
|
+
|
191
|
+
|
192
|
+
|
193
|
+
#-------------------------------------------------------------------------------------------------------------#
|
194
|
+
# text - A text node has been parsed
|
195
|
+
#
|
196
|
+
# txt - node text
|
197
|
+
#------------------------------------------------------------------------------------------------------------#
|
198
|
+
def text(txt)
|
199
|
+
puts "text: #{txt}" if $DEBUG
|
200
|
+
|
201
|
+
if (inRule?)
|
202
|
+
txt = cleanText(txt)
|
203
|
+
@curRuleSrc += txt
|
204
|
+
end
|
205
|
+
end
|
206
|
+
|
207
|
+
|
208
|
+
|
209
|
+
|
210
|
+
#-------------------------------------------------------------------------------------------------------------#
|
211
|
+
# cdata - A cdata node has been parsed
|
212
|
+
# Called when <![CDATA[ � ]]> is encountered in a document. @p content "�"
|
213
|
+
# txt - node text
|
214
|
+
#------------------------------------------------------------------------------------------------------------#
|
215
|
+
def cdata(txt)
|
216
|
+
if (inMsg?)
|
217
|
+
puts "cdata: #{txt}" unless !$DEBUG
|
218
|
+
@curRuleSrc += "<![CDATA[#{txt}]]>"
|
219
|
+
addMsg(txt)
|
220
|
+
end # if inMsg
|
221
|
+
end
|
222
|
+
|
223
|
+
|
224
|
+
|
225
|
+
|
226
|
+
#-------------------------------------------------------------------------------------------------------------#
|
227
|
+
# openRule - A Rule element has been started
|
228
|
+
#
|
229
|
+
# attributes - Rule element attributes
|
230
|
+
#
|
231
|
+
#------------------------------------------------------------------------------------------------------------#
|
232
|
+
def openRule(attributes)
|
233
|
+
if (inRule?)
|
234
|
+
closeRule()
|
235
|
+
end # if inRule
|
236
|
+
|
237
|
+
if ($DEBUG)
|
238
|
+
puts "openRule:"
|
239
|
+
|
240
|
+
if(!attributes.empty?)
|
241
|
+
puts " Attr:"
|
242
|
+
attributes.each do |attr|
|
243
|
+
puts " #{attr[0]}: #{attr[1]}"
|
244
|
+
end
|
245
|
+
end
|
246
|
+
end # if verbose
|
247
|
+
|
248
|
+
@inRule = true
|
249
|
+
|
250
|
+
@curRuleName = attributes['Name']
|
251
|
+
|
252
|
+
@curRuleSrc = String.new("<Rule")
|
253
|
+
@curRuleSrc += buildAttrString(attributes)
|
254
|
+
@curRuleSrc += ">"
|
255
|
+
|
256
|
+
puts "Collecting rule XML: #{@curRuleName}" if verbose?
|
257
|
+
|
258
|
+
end # openRule
|
259
|
+
|
260
|
+
|
261
|
+
|
262
|
+
|
263
|
+
#-------------------------------------------------------------------------------------------------------------#
|
264
|
+
# closeRule - A Rule element has been ended
|
265
|
+
#
|
266
|
+
#
|
267
|
+
#------------------------------------------------------------------------------------------------------------#
|
268
|
+
def closeRule()
|
269
|
+
puts "closeRule" if $DEBUG
|
270
|
+
|
271
|
+
if (inRule?)
|
272
|
+
@curRuleSrc += "</Rule>"
|
273
|
+
@context.rules[@curRuleName].xml = @curRuleSrc
|
274
|
+
@context.rules[@curRuleName].ifMsgs = @curIfMsgs
|
275
|
+
@context.rules[@curRuleName].elseMsgs = @curElseMsgs
|
276
|
+
@curRuleSrc = ""
|
277
|
+
@curRuleName = ""
|
278
|
+
@curIfMsgs = Array.new
|
279
|
+
@curElseMsgs = Array.new
|
280
|
+
|
281
|
+
@inRule = false
|
282
|
+
else
|
283
|
+
raise "Rule end tag encountered without preceeding start tag."
|
284
|
+
end # if inRule
|
285
|
+
end # closeRule
|
286
|
+
|
287
|
+
|
288
|
+
|
289
|
+
|
290
|
+
#-------------------------------------------------------------------------------------------------------------#
|
291
|
+
# openMessage - A Message element has been started
|
292
|
+
#
|
293
|
+
# attributes - Message element attributes
|
294
|
+
#
|
295
|
+
#------------------------------------------------------------------------------------------------------------#
|
296
|
+
def openMessage(attributes)
|
297
|
+
if ($DEBUG)
|
298
|
+
puts "openMessage"
|
299
|
+
|
300
|
+
if(!attributes.empty?)
|
301
|
+
puts " Attr:"
|
302
|
+
attributes.each do |attr|
|
303
|
+
puts " #{attr[0]}: #{attr[1]}"
|
304
|
+
end
|
305
|
+
end
|
306
|
+
end # if $DEBUG
|
307
|
+
|
308
|
+
@inMsg = true
|
309
|
+
|
310
|
+
@curRuleSrc += "<Message"
|
311
|
+
@curRuleSrc += buildAttrString(attributes)
|
312
|
+
@curRuleSrc += ">"
|
313
|
+
|
314
|
+
end # openMessage
|
315
|
+
|
316
|
+
|
317
|
+
|
318
|
+
|
319
|
+
#-------------------------------------------------------------------------------------------------------------#
|
320
|
+
# closeMessage - A Message element has been ended
|
321
|
+
#
|
322
|
+
#
|
323
|
+
#------------------------------------------------------------------------------------------------------------#
|
324
|
+
def closeMessage()
|
325
|
+
puts "closeMessage" if $DEBUG
|
326
|
+
if (inMsg?)
|
327
|
+
@curRuleSrc += "</Message>"
|
328
|
+
end # if inMsg
|
329
|
+
end # closeMessage
|
330
|
+
|
331
|
+
|
332
|
+
|
333
|
+
|
334
|
+
#-------------------------------------------------------------------------------------------------------------#
|
335
|
+
# openUnknown - A Unknown element has been started
|
336
|
+
#
|
337
|
+
# tag - Tag name of unknown element
|
338
|
+
# attributes - Unknown element attributes
|
339
|
+
#
|
340
|
+
#------------------------------------------------------------------------------------------------------------#
|
341
|
+
def openUnknown(tag, attributes)
|
342
|
+
if ($DEBUG)
|
343
|
+
puts "openUnknown: #{tag}"
|
344
|
+
|
345
|
+
if(!attributes.empty?)
|
346
|
+
puts " Attr:"
|
347
|
+
attributes.each do |attr|
|
348
|
+
puts " #{attr[0]}: #{attr[1]}"
|
349
|
+
end
|
350
|
+
end
|
351
|
+
end # if $DEBUG
|
352
|
+
|
353
|
+
if (inRule?)
|
354
|
+
@curRuleSrc += "<#{tag}"
|
355
|
+
@curRuleSrc += buildAttrString(attributes)
|
356
|
+
@curRuleSrc += ">"
|
357
|
+
end # if inRule
|
358
|
+
end # openUnknown
|
359
|
+
|
360
|
+
|
361
|
+
|
362
|
+
|
363
|
+
#-------------------------------------------------------------------------------------------------------------#
|
364
|
+
# closeUnknown - A Unknown element has been ended
|
365
|
+
#
|
366
|
+
# tag - Tag name of unknown element
|
367
|
+
#
|
368
|
+
#------------------------------------------------------------------------------------------------------------#
|
369
|
+
def closeUnknown(tag)
|
370
|
+
puts "closeUnknown: #{tag}" if $DEBUG
|
371
|
+
if (inRule?)
|
372
|
+
@curRuleSrc += "</#{tag}>"
|
373
|
+
end # if inRule
|
374
|
+
end # closeUnknown
|
375
|
+
|
376
|
+
|
377
|
+
|
378
|
+
|
379
|
+
#-------------------------------------------------------------------------------------------------------------#
|
380
|
+
# buildAttrString - Build an XML attribute string.
|
381
|
+
#
|
382
|
+
# attributes - Hash of attributes
|
383
|
+
#
|
384
|
+
#------------------------------------------------------------------------------------------------------------#
|
385
|
+
def buildAttrString(attributes)
|
386
|
+
str = ""
|
387
|
+
|
388
|
+
attributes.each do |key, val|
|
389
|
+
str += " #{key}='#{val}'"
|
390
|
+
end # attributes.each
|
391
|
+
|
392
|
+
puts "attrib str: #{str}" if $DEBUG
|
393
|
+
str
|
394
|
+
end # buildAttrString
|
395
|
+
|
396
|
+
|
397
|
+
|
398
|
+
|
399
|
+
#-------------------------------------------------------------------------------------------------------------#
|
400
|
+
# cleanText - Convert text into entities
|
401
|
+
#
|
402
|
+
# txt - text to convert
|
403
|
+
#
|
404
|
+
#------------------------------------------------------------------------------------------------------------#
|
405
|
+
def cleanText(txt)
|
406
|
+
clean = txt.gsub("<", "<")
|
407
|
+
clean.gsub!(">", ">")
|
408
|
+
|
409
|
+
puts "cleaned text: #{txt} -> #{clean}" if $DEBUG
|
410
|
+
clean
|
411
|
+
|
412
|
+
end # buildAttrString
|
413
|
+
end # class Listener
|
414
|
+
|
@@ -0,0 +1,112 @@
|
|
1
|
+
#
|
2
|
+
# File: ruleParser.rb
|
3
|
+
#
|
4
|
+
# This class will convert XML rule elements to GDL (Guideline Definition Language).
|
5
|
+
#
|
6
|
+
#
|
7
|
+
|
8
|
+
require 'rexml/document'
|
9
|
+
require 'rexml/streamlistener'
|
10
|
+
require 'xmlutils/xmlrulevisitor'
|
11
|
+
|
12
|
+
include REXML
|
13
|
+
|
14
|
+
|
15
|
+
#################################################
|
16
|
+
#
|
17
|
+
# class RuleParser
|
18
|
+
#
|
19
|
+
#################################################
|
20
|
+
class RuleParser
|
21
|
+
attr_accessor :context
|
22
|
+
|
23
|
+
#-------------------------------------------------------------------------------------------------------------#
|
24
|
+
# initialize - Constructor
|
25
|
+
#
|
26
|
+
#
|
27
|
+
#------------------------------------------------------------------------------------------------------------#
|
28
|
+
def initialize(ctx)
|
29
|
+
@verbose = false
|
30
|
+
@context = ctx
|
31
|
+
|
32
|
+
end
|
33
|
+
|
34
|
+
|
35
|
+
|
36
|
+
|
37
|
+
def verbose?
|
38
|
+
@verbose
|
39
|
+
end
|
40
|
+
|
41
|
+
|
42
|
+
|
43
|
+
|
44
|
+
#-------------------------------------------------------------------------------------------------------------#
|
45
|
+
# setFlag - Set configuration flags
|
46
|
+
#
|
47
|
+
# flg - Array of options or single string option. Currently, only -v: verbose is available
|
48
|
+
#
|
49
|
+
#------------------------------------------------------------------------------------------------------------#
|
50
|
+
def setFlag(flg)
|
51
|
+
if (flg.class == Array)
|
52
|
+
flg.each do |f|
|
53
|
+
case f
|
54
|
+
when '-v'
|
55
|
+
@verbose = true
|
56
|
+
end
|
57
|
+
end # flg.each
|
58
|
+
|
59
|
+
return
|
60
|
+
end # if flg
|
61
|
+
|
62
|
+
case flg
|
63
|
+
when '-v'
|
64
|
+
@verbose = true
|
65
|
+
end
|
66
|
+
|
67
|
+
end
|
68
|
+
|
69
|
+
|
70
|
+
|
71
|
+
|
72
|
+
#-------------------------------------------------------------------------------------------------------------#
|
73
|
+
# parse - Build a GDL rule definition from XML source.
|
74
|
+
#
|
75
|
+
# src - String containing XML source
|
76
|
+
# gdl - GDL rule definition.
|
77
|
+
#
|
78
|
+
#------------------------------------------------------------------------------------------------------------#
|
79
|
+
def parse(src)
|
80
|
+
doc = nil
|
81
|
+
doc = Document.new(src)
|
82
|
+
root = doc.root
|
83
|
+
|
84
|
+
return parseRuleXml(root)
|
85
|
+
|
86
|
+
end # def parse
|
87
|
+
|
88
|
+
|
89
|
+
|
90
|
+
|
91
|
+
#-------------------------------------------------------------------------------------------------------------#
|
92
|
+
# parseRuleXml - generate a GDL version of a rule definition based on Rule XML element
|
93
|
+
#
|
94
|
+
# rule - XML element to generate output for
|
95
|
+
#
|
96
|
+
# @returns GDL output for Rule definition
|
97
|
+
#
|
98
|
+
#------------------------------------------------------------------------------------------------------------#
|
99
|
+
def parseRuleXml(rule)
|
100
|
+
# arule = root.elements['//Rule'].to_a # returns all 1st level rule children elements
|
101
|
+
#ruleParts = rule.elements.to_a
|
102
|
+
puts "Parsing rule: #{rule.attributes['Name']}" if verbose?
|
103
|
+
|
104
|
+
visitor = XmlRuleVisitor.new(@context)
|
105
|
+
output = ""
|
106
|
+
|
107
|
+
return visitor.visit(rule, output)
|
108
|
+
|
109
|
+
|
110
|
+
end # parseRuleXml
|
111
|
+
end # class RuleParser
|
112
|
+
|
@@ -0,0 +1,86 @@
|
|
1
|
+
#
|
2
|
+
# File: varListener.rb
|
3
|
+
#
|
4
|
+
# This class is used to collect XML variables
|
5
|
+
#
|
6
|
+
#
|
7
|
+
|
8
|
+
require 'rexml/streamlistener'
|
9
|
+
require 'xmlutils/gdlcontext'
|
10
|
+
require 'xmlutils/gdlcontextobjs'
|
11
|
+
require 'xmlutils/listener'
|
12
|
+
|
13
|
+
include REXML
|
14
|
+
|
15
|
+
|
16
|
+
|
17
|
+
|
18
|
+
#################################################
|
19
|
+
#
|
20
|
+
# class VarListener
|
21
|
+
#
|
22
|
+
#################################################
|
23
|
+
class VarListener < Listener
|
24
|
+
|
25
|
+
attr_reader :context
|
26
|
+
|
27
|
+
|
28
|
+
|
29
|
+
|
30
|
+
#-------------------------------------------------------------------------------------------------------------#
|
31
|
+
# initialize - Ctor
|
32
|
+
#
|
33
|
+
# ctx - Context object to store variables in
|
34
|
+
#
|
35
|
+
#------------------------------------------------------------------------------------------------------------#
|
36
|
+
def initialize(ctx)
|
37
|
+
@verbose = false
|
38
|
+
@context = ctx
|
39
|
+
end
|
40
|
+
|
41
|
+
|
42
|
+
|
43
|
+
|
44
|
+
#-------------------------------------------------------------------------------------------------------------#
|
45
|
+
# openDPM - Add a DPM variable to the context object
|
46
|
+
#
|
47
|
+
# attributes - DPM element attributes
|
48
|
+
#
|
49
|
+
#------------------------------------------------------------------------------------------------------------#
|
50
|
+
def openDPM(attributes)
|
51
|
+
dpmAlias = attributes["Name"]
|
52
|
+
confName = @context.createValidName(dpmAlias)
|
53
|
+
varType = attributes["Type"]
|
54
|
+
dataType = attributes["DataType"] if attributes.has_key?("DataType")
|
55
|
+
prodType = attributes["ProductType"]
|
56
|
+
|
57
|
+
dataType = prodType if nil == dataType
|
58
|
+
|
59
|
+
dpm = Dpm.new(confName, dpmAlias, varType, dataType, prodType)
|
60
|
+
|
61
|
+
@context.dpms[dpmAlias] = dpm
|
62
|
+
end # openDPM
|
63
|
+
|
64
|
+
|
65
|
+
|
66
|
+
|
67
|
+
#-------------------------------------------------------------------------------------------------------------#
|
68
|
+
# openPPM - Add a PPM variable to the context object
|
69
|
+
#
|
70
|
+
# attributes - PPM element attributes
|
71
|
+
#
|
72
|
+
#------------------------------------------------------------------------------------------------------------#
|
73
|
+
def openPPM(attributes)
|
74
|
+
ppmAlias = attributes["Name"]
|
75
|
+
confName = @context.createValidName(ppmAlias)
|
76
|
+
varType = attributes["Type"]
|
77
|
+
dataType = attributes["DataType"] if attributes.has_key?("DataType")
|
78
|
+
|
79
|
+
dataType = "Text" if nil == dataType
|
80
|
+
|
81
|
+
ppm = Ppm.new(confName, ppmAlias, varType, dataType)
|
82
|
+
|
83
|
+
@context.ppms[ppmAlias] = ppm
|
84
|
+
end # openPPM
|
85
|
+
end # class VarListener
|
86
|
+
|