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,704 @@
|
|
1
|
+
#
|
2
|
+
# File: XmlRuleVisitor.rb
|
3
|
+
#
|
4
|
+
# This class is used to visit XML guideline elements
|
5
|
+
#
|
6
|
+
#
|
7
|
+
|
8
|
+
require 'rexml/document'
|
9
|
+
require 'rexml/streamlistener'
|
10
|
+
require 'logger'
|
11
|
+
require 'xmlutils/xmlvisitor'
|
12
|
+
require 'xmlutils/gdltemplate'
|
13
|
+
|
14
|
+
#################################################
|
15
|
+
#
|
16
|
+
# class XmlRuleVisitor
|
17
|
+
#
|
18
|
+
#################################################
|
19
|
+
class XmlRuleVisitor < XmlVisitor
|
20
|
+
include REXML
|
21
|
+
|
22
|
+
attr_accessor :lookupData
|
23
|
+
attr_accessor :context
|
24
|
+
attr_accessor :template
|
25
|
+
|
26
|
+
|
27
|
+
|
28
|
+
#-------------------------------------------------------------------------------------------------------------#
|
29
|
+
# initialize - Constructor
|
30
|
+
#
|
31
|
+
#
|
32
|
+
#------------------------------------------------------------------------------------------------------------#
|
33
|
+
def initialize(ctx)
|
34
|
+
super()
|
35
|
+
@output = ""
|
36
|
+
@lookupData = Hash.new
|
37
|
+
@context = ctx
|
38
|
+
@template = GdlTemplate.new
|
39
|
+
|
40
|
+
#@log = Logger.new(STDOUT)
|
41
|
+
#@log.level = Logger::DEBUG
|
42
|
+
|
43
|
+
|
44
|
+
end
|
45
|
+
|
46
|
+
|
47
|
+
|
48
|
+
|
49
|
+
#-------------------------------------------------------------------------------------------------------------#
|
50
|
+
# generateMsg - Generate a message
|
51
|
+
#
|
52
|
+
# msgTxt - Text of message. Used to lookup message details from context
|
53
|
+
#
|
54
|
+
# @returns GDL output
|
55
|
+
#
|
56
|
+
#------------------------------------------------------------------------------------------------------------#
|
57
|
+
def generateMsg(msgTxt)
|
58
|
+
msgOut = ""
|
59
|
+
msgData = @context.messages[msgTxt]
|
60
|
+
|
61
|
+
if (nil != msgData)
|
62
|
+
msgOut = @template.msg(msgData)
|
63
|
+
end
|
64
|
+
|
65
|
+
msgOut
|
66
|
+
end # generateMsg
|
67
|
+
|
68
|
+
|
69
|
+
|
70
|
+
|
71
|
+
#-------------------------------------------------------------------------------------------------------------#
|
72
|
+
# visitRule - Handle default parsing
|
73
|
+
#
|
74
|
+
# elem - Element to visit
|
75
|
+
# data - output object to append GDL text to
|
76
|
+
#
|
77
|
+
# @returns GDL output
|
78
|
+
#
|
79
|
+
#------------------------------------------------------------------------------------------------------------#
|
80
|
+
def visitRule(elem, data)
|
81
|
+
@@log.debug("XmlRuleVisitor::visitRule")
|
82
|
+
@@log.debug(elem.inspect)
|
83
|
+
|
84
|
+
|
85
|
+
ruleAlias = elem.attributes['Name']
|
86
|
+
ruleData = @context.rules[ruleAlias]
|
87
|
+
raise "Rule data not found: #{ruleAlias}" unless (ruleData.kind_of? Rule)
|
88
|
+
|
89
|
+
ruleName = ruleData.name
|
90
|
+
|
91
|
+
ruleCond = ""
|
92
|
+
elem.each_element do |child|
|
93
|
+
if ("Condition" == child.name)
|
94
|
+
ruleCond = visit(child, ruleCond)
|
95
|
+
break
|
96
|
+
end
|
97
|
+
end
|
98
|
+
|
99
|
+
ifActions = ""
|
100
|
+
elem.each_element do |child|
|
101
|
+
if ("IfActions" == child.name)
|
102
|
+
ifActions = visit(child, ifActions)
|
103
|
+
break
|
104
|
+
end
|
105
|
+
end
|
106
|
+
|
107
|
+
elseActions = ""
|
108
|
+
elem.each_element do |child|
|
109
|
+
if ("ElseActions" == child.name)
|
110
|
+
elseActions = visit(child, elseActions)
|
111
|
+
break
|
112
|
+
end
|
113
|
+
end
|
114
|
+
|
115
|
+
|
116
|
+
ifMsgs = "" # Generate 'If' messages
|
117
|
+
ruleData.ifMsgs.each do |msgTxt|
|
118
|
+
ifMsgs += generateMsg(msgTxt)
|
119
|
+
end # ifMsgs.each
|
120
|
+
|
121
|
+
elseMsgs = "" # Generate 'Else' messages
|
122
|
+
ruleData.elseMsgs.each do |msgTxt|
|
123
|
+
elseMsgs += generateMsg(msgTxt)
|
124
|
+
end # ifMsgs.each
|
125
|
+
|
126
|
+
|
127
|
+
|
128
|
+
aliasStmt = "" # Don't create an alias statement if it is not needed.
|
129
|
+
if (ruleName != ruleAlias)
|
130
|
+
aliasStmt = <<EOF
|
131
|
+
alias(rule, #{ruleName}, "#{ruleAlias}");
|
132
|
+
EOF
|
133
|
+
end # if rulename...
|
134
|
+
|
135
|
+
# Create rule template
|
136
|
+
output = <<EOF
|
137
|
+
#{aliasStmt}
|
138
|
+
// ############################################
|
139
|
+
// #{ruleName}
|
140
|
+
|
141
|
+
rule #{ruleName}()
|
142
|
+
if(
|
143
|
+
#{ruleCond}
|
144
|
+
)
|
145
|
+
then
|
146
|
+
#{ifActions}
|
147
|
+
#{ifMsgs}
|
148
|
+
EOF
|
149
|
+
|
150
|
+
if (elseActions.length > 0)
|
151
|
+
output += <<EOF
|
152
|
+
else
|
153
|
+
#{elseActions}
|
154
|
+
#{elseMsgs}
|
155
|
+
EOF
|
156
|
+
end
|
157
|
+
|
158
|
+
output += <<EOF
|
159
|
+
end
|
160
|
+
end // rule
|
161
|
+
|
162
|
+
|
163
|
+
|
164
|
+
|
165
|
+
EOF
|
166
|
+
|
167
|
+
data += output
|
168
|
+
return data
|
169
|
+
end # visitRule
|
170
|
+
|
171
|
+
|
172
|
+
|
173
|
+
|
174
|
+
#-------------------------------------------------------------------------------------------------------------#
|
175
|
+
# visitXmlFunction - Handle default parsing
|
176
|
+
#
|
177
|
+
# elem - Element to visit
|
178
|
+
# data - output object to append GDL text to
|
179
|
+
#
|
180
|
+
# @returns GDL output
|
181
|
+
#
|
182
|
+
#------------------------------------------------------------------------------------------------------------#
|
183
|
+
def visitXmlFunction(elem, data)
|
184
|
+
@@log.debug("XmlRuleVisitor::visitXmlFunction")
|
185
|
+
@@log.debug(elem.inspect)
|
186
|
+
|
187
|
+
funcName = elem.attributes['Name']
|
188
|
+
|
189
|
+
funcArgs = ''
|
190
|
+
elem.each_element do |child|
|
191
|
+
funcArgs = visit(child, funcArgs)
|
192
|
+
end
|
193
|
+
|
194
|
+
output = "#{funcName}#{funcArgs}"
|
195
|
+
data += output
|
196
|
+
return data
|
197
|
+
end # visitXmlFunction
|
198
|
+
|
199
|
+
|
200
|
+
#-------------------------------------------------------------------------------------------------------------#
|
201
|
+
# visitArgs - Handle default parsing
|
202
|
+
#
|
203
|
+
# elem - Element to visit
|
204
|
+
# data - output object to append GDL text to
|
205
|
+
#
|
206
|
+
# @returns GDL output
|
207
|
+
#
|
208
|
+
#------------------------------------------------------------------------------------------------------------#
|
209
|
+
def visitArgs(elem, data)
|
210
|
+
@@log.debug("XmlRuleVisitor::visitArgs")
|
211
|
+
@@log.debug(elem.inspect)
|
212
|
+
|
213
|
+
argsData = ''
|
214
|
+
elem.each_element do |child|
|
215
|
+
argsData = visit(child, argsData)
|
216
|
+
end
|
217
|
+
|
218
|
+
output = "( #{argsData} )"
|
219
|
+
data += output
|
220
|
+
return data
|
221
|
+
end # visitArgs
|
222
|
+
|
223
|
+
|
224
|
+
#-------------------------------------------------------------------------------------------------------------#
|
225
|
+
# visitArg - Handle default parsing
|
226
|
+
#
|
227
|
+
# elem - Element to visit
|
228
|
+
# data - output object to append GDL text to
|
229
|
+
#
|
230
|
+
# @returns GDL output
|
231
|
+
#
|
232
|
+
#------------------------------------------------------------------------------------------------------------#
|
233
|
+
def visitArg(elem, data)
|
234
|
+
@@log.debug("XmlRuleVisitor::visitArg")
|
235
|
+
@@log.debug(elem.inspect)
|
236
|
+
|
237
|
+
argData = ''
|
238
|
+
|
239
|
+
elem.each_element do |child|
|
240
|
+
argData += ", " if(!data.empty?)
|
241
|
+
argData = visit(child, argData)
|
242
|
+
end
|
243
|
+
|
244
|
+
data += argData
|
245
|
+
return data
|
246
|
+
end # visitArg
|
247
|
+
|
248
|
+
|
249
|
+
#-------------------------------------------------------------------------------------------------------------#
|
250
|
+
# visitCompute - Handle default parsing
|
251
|
+
#
|
252
|
+
# elem - Element to visit
|
253
|
+
# data - output object to append GDL text to
|
254
|
+
#
|
255
|
+
# @returns GDL output
|
256
|
+
#
|
257
|
+
#------------------------------------------------------------------------------------------------------------#
|
258
|
+
def visitCompute(elem, data)
|
259
|
+
@@log.debug("XmlRuleVisitor::visitCompute")
|
260
|
+
@@log.debug(elem.inspect)
|
261
|
+
|
262
|
+
if (3 != elem.elements.size)
|
263
|
+
@@log.error("Compute element did not have the expected number of child elements.")
|
264
|
+
return data
|
265
|
+
end
|
266
|
+
|
267
|
+
# visit the left side
|
268
|
+
data = visit(elem.elements[2], data)
|
269
|
+
|
270
|
+
# visit the operator
|
271
|
+
data = visit(elem.elements[1], data)
|
272
|
+
|
273
|
+
# visit the right side
|
274
|
+
data = visit(elem.elements[3], data)
|
275
|
+
|
276
|
+
return data
|
277
|
+
end # visitCompute
|
278
|
+
|
279
|
+
|
280
|
+
|
281
|
+
|
282
|
+
#-------------------------------------------------------------------------------------------------------------#
|
283
|
+
# visitExpression - Handle default parsing
|
284
|
+
#
|
285
|
+
# elem - Element to visit
|
286
|
+
# data - output object to append GDL text to
|
287
|
+
#
|
288
|
+
# @returns GDL output
|
289
|
+
#
|
290
|
+
#------------------------------------------------------------------------------------------------------------#
|
291
|
+
def visitExpression(elem, data)
|
292
|
+
@@log.debug("XmlRuleVisitor::visitExpression")
|
293
|
+
@@log.debug(elem.inspect)
|
294
|
+
|
295
|
+
elem.each_element do |child|
|
296
|
+
data = visit(child, data)
|
297
|
+
end
|
298
|
+
|
299
|
+
return data
|
300
|
+
end # visitExpression
|
301
|
+
|
302
|
+
|
303
|
+
|
304
|
+
|
305
|
+
#-------------------------------------------------------------------------------------------------------------#
|
306
|
+
# visitLeftOperand - Handle default parsing
|
307
|
+
#
|
308
|
+
# elem - Element to visit
|
309
|
+
# data - output object to append GDL text to
|
310
|
+
#
|
311
|
+
# @returns GDL output
|
312
|
+
#
|
313
|
+
#------------------------------------------------------------------------------------------------------------#
|
314
|
+
def visitLeftOperand(elem, data)
|
315
|
+
@@log.debug("XmlRuleVisitor::visitLeftOperand")
|
316
|
+
@@log.debug(elem.inspect)
|
317
|
+
|
318
|
+
elem.each_element do |child|
|
319
|
+
data = visit(child, data)
|
320
|
+
end
|
321
|
+
|
322
|
+
return data
|
323
|
+
end # visitLeftOperand
|
324
|
+
|
325
|
+
|
326
|
+
|
327
|
+
|
328
|
+
#-------------------------------------------------------------------------------------------------------------#
|
329
|
+
# visitRightOperand - Handle default parsing
|
330
|
+
#
|
331
|
+
# elem - Element to visit
|
332
|
+
# data - output object to append GDL text to
|
333
|
+
#
|
334
|
+
# @returns GDL output
|
335
|
+
#
|
336
|
+
#------------------------------------------------------------------------------------------------------------#
|
337
|
+
def visitRightOperand(elem, data)
|
338
|
+
@@log.debug("XmlRuleVisitor::visitRightOperand")
|
339
|
+
@@log.debug(elem.inspect)
|
340
|
+
|
341
|
+
elem.each_element do |child|
|
342
|
+
data = visit(child, data)
|
343
|
+
end
|
344
|
+
|
345
|
+
return data
|
346
|
+
end # visitRightOperand
|
347
|
+
|
348
|
+
|
349
|
+
|
350
|
+
|
351
|
+
#-------------------------------------------------------------------------------------------------------------#
|
352
|
+
# visitOperator - Handle default parsing
|
353
|
+
#
|
354
|
+
# elem - Element to visit
|
355
|
+
# data - output object to append GDL text to
|
356
|
+
#
|
357
|
+
# @returns GDL output
|
358
|
+
#
|
359
|
+
#------------------------------------------------------------------------------------------------------------#
|
360
|
+
def visitOperator(elem, data)
|
361
|
+
@@log.debug("XmlRuleVisitor::visitOperator")
|
362
|
+
@@log.debug(elem.inspect)
|
363
|
+
|
364
|
+
if (!elem.has_text?)
|
365
|
+
@@log.error("An OPERATOR element does not have any text.")
|
366
|
+
return data
|
367
|
+
end
|
368
|
+
|
369
|
+
case elem.text
|
370
|
+
when '<'
|
371
|
+
data += ' < '
|
372
|
+
|
373
|
+
when '>'
|
374
|
+
data += ' > '
|
375
|
+
|
376
|
+
when '<>', '<>'
|
377
|
+
data += ' != '
|
378
|
+
|
379
|
+
when 'OR'
|
380
|
+
data += " ||\n\t\t"
|
381
|
+
|
382
|
+
when 'AND'
|
383
|
+
data += " &&\n\t\t"
|
384
|
+
|
385
|
+
else
|
386
|
+
data += " #{elem.text} "
|
387
|
+
end
|
388
|
+
|
389
|
+
return data
|
390
|
+
end # visitOperator
|
391
|
+
|
392
|
+
|
393
|
+
|
394
|
+
|
395
|
+
#-------------------------------------------------------------------------------------------------------------#
|
396
|
+
# visitBrace - Handle default parsing
|
397
|
+
#
|
398
|
+
# elem - Element to visit
|
399
|
+
# data - output object to append GDL text to
|
400
|
+
#
|
401
|
+
# @returns GDL output
|
402
|
+
#
|
403
|
+
#------------------------------------------------------------------------------------------------------------#
|
404
|
+
def visitBrace(elem, data)
|
405
|
+
@@log.debug("XmlRuleVisitor::visitBrace")
|
406
|
+
@@log.debug(elem.inspect)
|
407
|
+
|
408
|
+
data += "("
|
409
|
+
|
410
|
+
elem.each_element do |child|
|
411
|
+
data = visit(child, data)
|
412
|
+
end
|
413
|
+
|
414
|
+
data += ")"
|
415
|
+
|
416
|
+
return data
|
417
|
+
end # visitBrace
|
418
|
+
|
419
|
+
|
420
|
+
|
421
|
+
|
422
|
+
#-------------------------------------------------------------------------------------------------------------#
|
423
|
+
# visitConstant - Handle default parsing
|
424
|
+
#
|
425
|
+
# elem - Element to visit
|
426
|
+
# data - output object to append GDL text to
|
427
|
+
#
|
428
|
+
# @returns GDL output
|
429
|
+
#
|
430
|
+
#------------------------------------------------------------------------------------------------------------#
|
431
|
+
def visitConstant(elem, data)
|
432
|
+
@@log.debug("XmlRuleVisitor::visitConstant")
|
433
|
+
@@log.debug(elem.inspect)
|
434
|
+
|
435
|
+
if (!elem.has_text?)
|
436
|
+
@@log.error("A CONSTANT element does not have any text.")
|
437
|
+
return data
|
438
|
+
end
|
439
|
+
|
440
|
+
text = elem.text
|
441
|
+
num = isNumber(text)
|
442
|
+
if (nil != num)
|
443
|
+
data += num.to_s # TODO Fix the fact that numbers are also returned as text.
|
444
|
+
else
|
445
|
+
data += "\"#{text}\""
|
446
|
+
end
|
447
|
+
|
448
|
+
return data
|
449
|
+
end # visitConstant
|
450
|
+
|
451
|
+
|
452
|
+
|
453
|
+
|
454
|
+
|
455
|
+
#-------------------------------------------------------------------------------------------------------------#
|
456
|
+
# isNumber - Determine if a string is in fact a number
|
457
|
+
#
|
458
|
+
# text - string to check
|
459
|
+
#
|
460
|
+
# @returns boolean
|
461
|
+
#
|
462
|
+
#------------------------------------------------------------------------------------------------------------#
|
463
|
+
def isNumber(text)
|
464
|
+
@@log.debug("XmlRuleVisitor::isNumber")
|
465
|
+
@@log.debug(text.inspect)
|
466
|
+
|
467
|
+
if (nil != text.index('.'))
|
468
|
+
num = text.to_f
|
469
|
+
if (num.to_s == text)
|
470
|
+
@@log.debug("isNumber: float: #{num.to_s}")
|
471
|
+
return num
|
472
|
+
end # if num
|
473
|
+
end # if nil
|
474
|
+
|
475
|
+
num = text.to_i
|
476
|
+
if (num.to_s == text)
|
477
|
+
@@log.debug("isNumber: int: #{num.to_s}")
|
478
|
+
return num
|
479
|
+
end # if num
|
480
|
+
|
481
|
+
return nil
|
482
|
+
|
483
|
+
end # isNumber
|
484
|
+
|
485
|
+
|
486
|
+
|
487
|
+
|
488
|
+
#-------------------------------------------------------------------------------------------------------------#
|
489
|
+
# visitPPM - Handle default parsing
|
490
|
+
#
|
491
|
+
# elem - Element to visit
|
492
|
+
# data - output object to append GDL text to
|
493
|
+
#
|
494
|
+
# @returns GDL output
|
495
|
+
#
|
496
|
+
#------------------------------------------------------------------------------------------------------------#
|
497
|
+
def visitPPM(elem, data)
|
498
|
+
@@log.debug("XmlRuleVisitor::visitPPM")
|
499
|
+
@@log.debug(elem.inspect)
|
500
|
+
|
501
|
+
varName = @context.ppms[elem.attributes['Name']].name
|
502
|
+
|
503
|
+
data += varName
|
504
|
+
|
505
|
+
return data
|
506
|
+
end # visitPPM
|
507
|
+
|
508
|
+
|
509
|
+
|
510
|
+
|
511
|
+
#-------------------------------------------------------------------------------------------------------------#
|
512
|
+
# visitDPM - Handle default parsing
|
513
|
+
#
|
514
|
+
# elem - Element to visit
|
515
|
+
# data - output object to append GDL text to
|
516
|
+
#
|
517
|
+
# @returns GDL output
|
518
|
+
#
|
519
|
+
#------------------------------------------------------------------------------------------------------------#
|
520
|
+
def visitDPM(elem, data)
|
521
|
+
@@log.debug("XmlRuleVisitor::visitDPM")
|
522
|
+
@@log.debug(elem.inspect)
|
523
|
+
|
524
|
+
varName = @context.dpms[elem.attributes['Name']].name
|
525
|
+
|
526
|
+
data += varName
|
527
|
+
|
528
|
+
return data
|
529
|
+
end # visitDPM
|
530
|
+
|
531
|
+
|
532
|
+
|
533
|
+
|
534
|
+
#-------------------------------------------------------------------------------------------------------------#
|
535
|
+
# visitAssign - Handle default parsing
|
536
|
+
#
|
537
|
+
# elem - Element to visit
|
538
|
+
# data - output object to append GDL text to
|
539
|
+
#
|
540
|
+
# @returns GDL output
|
541
|
+
#
|
542
|
+
#------------------------------------------------------------------------------------------------------------#
|
543
|
+
def visitAssign(elem, data)
|
544
|
+
@@log.debug("XmlRuleVisitor::visitAssign")
|
545
|
+
@@log.debug(elem.inspect)
|
546
|
+
|
547
|
+
if (elem.elements.size < 1)
|
548
|
+
@@log.error("Assign element has no children.")
|
549
|
+
end
|
550
|
+
|
551
|
+
if (2 != elem.elements.size)
|
552
|
+
@@log.error("Assign element did not have the expected number of child elements.")
|
553
|
+
return data
|
554
|
+
end
|
555
|
+
|
556
|
+
# visit the left side
|
557
|
+
data = visit(elem.elements[1], data)
|
558
|
+
|
559
|
+
data += " = " # Add the equals sign.
|
560
|
+
|
561
|
+
# visit the assignment
|
562
|
+
data = visit(elem.elements[2], data)
|
563
|
+
|
564
|
+
data += ";\n\t\t" # Terminate the statement.
|
565
|
+
|
566
|
+
return data
|
567
|
+
end # visitAssign
|
568
|
+
|
569
|
+
|
570
|
+
|
571
|
+
|
572
|
+
#-------------------------------------------------------------------------------------------------------------#
|
573
|
+
# visitAssignTo - Handle default parsing
|
574
|
+
#
|
575
|
+
# elem - Element to visit
|
576
|
+
# data - output object to append GDL text to
|
577
|
+
#
|
578
|
+
# @returns GDL output
|
579
|
+
#
|
580
|
+
#------------------------------------------------------------------------------------------------------------#
|
581
|
+
def visitAssignTo(elem, data)
|
582
|
+
@@log.debug("XmlRuleVisitor::visitAssignTo")
|
583
|
+
@@log.debug(elem.inspect)
|
584
|
+
|
585
|
+
if (elem.elements.size < 1)
|
586
|
+
@@log.error("AssignTo element has no children.")
|
587
|
+
end
|
588
|
+
|
589
|
+
elem.each_element do |child|
|
590
|
+
data = visit(child, data)
|
591
|
+
end
|
592
|
+
|
593
|
+
return data
|
594
|
+
end # visitAssignTo
|
595
|
+
|
596
|
+
|
597
|
+
|
598
|
+
|
599
|
+
#-------------------------------------------------------------------------------------------------------------#
|
600
|
+
# visitAssignValue - Handle default parsing
|
601
|
+
#
|
602
|
+
# elem - Element to visit
|
603
|
+
# data - output object to append GDL text to
|
604
|
+
#
|
605
|
+
# @returns GDL output
|
606
|
+
#
|
607
|
+
#------------------------------------------------------------------------------------------------------------#
|
608
|
+
def visitAssignValue(elem, data)
|
609
|
+
@@log.debug("XmlRuleVisitor::visitAssignValue")
|
610
|
+
@@log.debug(elem.inspect)
|
611
|
+
|
612
|
+
if (elem.elements.size < 1)
|
613
|
+
@@log.error("AssignValue element has no children.")
|
614
|
+
end
|
615
|
+
|
616
|
+
elem.each_element do |child|
|
617
|
+
data = visit(child, data)
|
618
|
+
end
|
619
|
+
|
620
|
+
return data
|
621
|
+
end # visitAssignValue
|
622
|
+
|
623
|
+
|
624
|
+
|
625
|
+
|
626
|
+
#-------------------------------------------------------------------------------------------------------------#
|
627
|
+
# visitLookup - Handle default parsing
|
628
|
+
#
|
629
|
+
# elem - Element to visit
|
630
|
+
# data - output object to append GDL text to
|
631
|
+
#
|
632
|
+
# @returns GDL output
|
633
|
+
#
|
634
|
+
#------------------------------------------------------------------------------------------------------------#
|
635
|
+
def visitLookup(elem, data)
|
636
|
+
@@log.debug("XmlRuleVisitor::visitLookup")
|
637
|
+
@@log.debug(elem.inspect)
|
638
|
+
|
639
|
+
lkName = elem.attributes['Name']
|
640
|
+
lkParams = @context.getLookupParamNames(lkName)
|
641
|
+
|
642
|
+
data += @template.lookup(lkName, lkParams["xparam"], lkParams["yparam"])
|
643
|
+
|
644
|
+
return data
|
645
|
+
|
646
|
+
lkup = @context.lookups[lkName]
|
647
|
+
|
648
|
+
#puts lkup.inspect
|
649
|
+
|
650
|
+
x = nil
|
651
|
+
y = nil
|
652
|
+
|
653
|
+
if (isPpmVar(lkup.xParam))
|
654
|
+
x = @context.ppms[lkup.xParam.alias]
|
655
|
+
else
|
656
|
+
x = @context.dpms[lkup.xParam.alias]
|
657
|
+
end # if PPM
|
658
|
+
|
659
|
+
#puts x.inspect
|
660
|
+
|
661
|
+
if (isPpmVar(lkup.yParam))
|
662
|
+
y = @context.ppms[lkup.yParam.alias]
|
663
|
+
else
|
664
|
+
y = @context.dpms[lkup.yParam.alias]
|
665
|
+
end # if PPM
|
666
|
+
|
667
|
+
#puts y.inspect
|
668
|
+
|
669
|
+
if (nil == x)
|
670
|
+
raise "Unable to find xParam (#{lkup.xParam.alias}) in lookup #{lkName}"
|
671
|
+
end # if nil
|
672
|
+
|
673
|
+
if (nil == y)
|
674
|
+
raise "Unable to find yParam (#{lkup.yParam.alias}) in lookup #{lkName}"
|
675
|
+
end # if nil
|
676
|
+
|
677
|
+
# data += lkup.toGdlRef()
|
678
|
+
data += @template.lookup(lkName, x.name, y.name)
|
679
|
+
|
680
|
+
return data
|
681
|
+
end # visitLookup
|
682
|
+
|
683
|
+
|
684
|
+
|
685
|
+
|
686
|
+
def isPpmVar(var)
|
687
|
+
isPpm = false
|
688
|
+
|
689
|
+
case var.varType
|
690
|
+
when 'app'
|
691
|
+
isPpm = true
|
692
|
+
|
693
|
+
when 'crd'
|
694
|
+
isPpm = true
|
695
|
+
|
696
|
+
when 'prd'
|
697
|
+
isPpm = true
|
698
|
+
|
699
|
+
end # case
|
700
|
+
|
701
|
+
isPpm
|
702
|
+
end # isPpmVar
|
703
|
+
end # class XmlRuleVisitor
|
704
|
+
|