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.
Files changed (53) hide show
  1. checksums.yaml +7 -0
  2. data/.gitignore +6 -0
  3. data/Gemfile +4 -0
  4. data/LICENSE +22 -0
  5. data/README.md +77 -0
  6. data/bin/xmltogdl +88 -0
  7. data/docs/README.txt +20 -0
  8. data/lib/xmlutils/contextlistener.rb +432 -0
  9. data/lib/xmlutils/contextparser.rb +111 -0
  10. data/lib/xmlutils/dumplistener.rb +57 -0
  11. data/lib/xmlutils/gdlcontext.rb +305 -0
  12. data/lib/xmlutils/gdlcontextobjs.rb +286 -0
  13. data/lib/xmlutils/gdldoc.rb +547 -0
  14. data/lib/xmlutils/gdldocbuilder.rb +181 -0
  15. data/lib/xmlutils/gdllistener.rb +265 -0
  16. data/lib/xmlutils/gdltemplate.rb +488 -0
  17. data/lib/xmlutils/lineparser.rb +193 -0
  18. data/lib/xmlutils/listener.rb +459 -0
  19. data/lib/xmlutils/rulelistener.rb +414 -0
  20. data/lib/xmlutils/ruleparser.rb +112 -0
  21. data/lib/xmlutils/varlistener.rb +86 -0
  22. data/lib/xmlutils/version.rb +5 -0
  23. data/lib/xmlutils/xmlrulevisitor.rb +704 -0
  24. data/lib/xmlutils/xmltogdlcontroller.rb +93 -0
  25. data/lib/xmlutils/xmltogdltask.rb +23 -0
  26. data/lib/xmlutils/xmlvisitor.rb +690 -0
  27. data/lib/xmlutils.rb +40 -0
  28. data/rakefile.rb +34 -0
  29. data/unittests/2830.xml +1 -0
  30. data/unittests/chunks.rb +31 -0
  31. data/unittests/curDirTest.rb +2 -0
  32. data/unittests/data/2830-GENERATED.gdl +309 -0
  33. data/unittests/data/2830-GENERATED.xml +1 -0
  34. data/unittests/data/AUGuideline.xml +12 -0
  35. data/unittests/data/AUGuideline.xml.gdl +19190 -0
  36. data/unittests/data/BAKUP.DCTEST1.xml +1 -0
  37. data/unittests/data/DCTEST.xml +1 -0
  38. data/unittests/data/DCTEST1.xml +1 -0
  39. data/unittests/data/DCTEST1.xml.gdl +14890 -0
  40. data/unittests/data/DCTEST1.xml.rename.csv +180 -0
  41. data/unittests/data/DCTEST1wLookups.xml +174 -0
  42. data/unittests/data/DCTEST1wLookups.xml.gdl +127 -0
  43. data/unittests/data/GENERATED.gdl.xml +1 -0
  44. data/unittests/data/Message.xml +1 -0
  45. data/unittests/data/Message.xml.gdl +142 -0
  46. data/unittests/data/Pricing2ndGuideline.xml +1 -0
  47. data/unittests/data/Pricing2ndGuideline.xml.gdl +52670 -0
  48. data/unittests/data/Z-TEMP-Jeff.xml +1 -0
  49. data/unittests/data/Z-TEMP-Jeff.xml.gdl +288 -0
  50. data/unittests/tc_convert_xml_to_gdl.rb +23 -0
  51. data/unittests/ts_allTests.rb +2 -0
  52. data/xmlutils.gemspec +25 -0
  53. 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 '&lt;'
371
+ data += ' < '
372
+
373
+ when '&gt;'
374
+ data += ' > '
375
+
376
+ when '&lt;&gt;', '<>'
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
+