xmlutils 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7d719bedccfde3e165b008fe9b2c6b4f0ef6e8c5
+  data.tar.gz: e2ab6f96b483cfd0506d1a7d870d344dff60e139
+SHA512:
+  metadata.gz: 892232ad6620675da30f3155109ddcb2f48a48077d9601759c9ff01a3e41bdcb4430376338aa054ad842030fb074b646cee4e0a05c4b541746a0953e885ffe33
+  data.tar.gz: 4ffcefc03b8fb81e0d53166dff35bce911fba1fd6ae6c1d0e6efda387905ee0376da17069afe6d0f8d97c9c5d123ecf6f6b3ff33affb87e97cc4650888b33ae1

data/.gitignore

@@ -0,0 +1,6 @@
+# .gitignore
+
+buildgem
+buildgem.cmd
+pkg/
+tmp/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in test.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Jeff McAffee
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,77 @@
+# XmlUtils
+
+## Summary
+
+The XmlUtils library provides XML related helper objects.
+
+An application (`xmltogdl`) is also provided to convert AMS XML guidelines
+to the GDL language. See [GDLC](https://github.com/jmcaffee/gdlc) for more
+information about GDL.
+
+## Installation
+
+Add this line to your gemfile:
+
+    gem 'xmlutils'
+
+And then execute:
+
+    $ bundle install
+
+or install it yourself as:
+
+    $ gem install xmlutils
+
+## Usage
+
+### Command Line Application
+
+Usage info can be retrieved from the application by calling it with the `-h` or `--help`
+options:
+
+    $ xmltogdl --help
+
+### Rake Task Usage
+
+The rake task can be included in a rakefile by requiring `xmlutils/xmltogdltask`:
+
+    require `xmlutils/xmltogdltask`
+
+and called as:
+
+    XmlToGdlTask.new.execute(src_path, dest_path, verbose_true_or_false);
+
+## Testing
+
+XmlUtils will use RSpec for testing, but it currently only has simple
+hand-rolled tests in the `unittests` directory.
+
+To run all existing specs (none at this time):
+
+    $ rake spec
+
+or directly:
+
+    $ bundle exec rspec
+
+## TODO
+
+Update the naming convention of methods to the ruby standard.
+
+## Contributing
+
+1. Fork it ( https://github.com/jmcaffee/xmlutils/fork )
+1. Clone it (`git clone git@github.com:[my-github-username]/xmlutils.git`)
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Create tests for your feature branch
+4. Commit your changes (`git commit -am 'Add some feature'`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create a new Pull Request
+
+## LICENSE
+
+XmlUtils is licensed under the MIT license.
+
+See [LICENSE](https://github.com/jmcaffee/xmlutils/blob/master/LICENSE) for
+details.
+

data/bin/xmltogdl

@@ -0,0 +1,88 @@
+#! C:/tools/Ruby/bin/ruby.exe
+##############################################################################
+# File:: xmltogdl
+# Purpose:: Utility to convert XML guideline files to gdl source
+# 
+# Author::    Jeff McAffee 03/07/2010
+# Copyright:: Copyright (c) 2010, kTech Systems LLC. All rights reserved.
+# Website::   http://ktechsystems.com
+##############################################################################
+
+require 'xmlUtils'
+require 'user-choices'
+
+
+class XmlToGdlApp < UserChoices::Command
+    include UserChoices
+
+    
+    def initialize()
+        super
+        @controller = XmlToGdlController.new
+    end
+    
+    
+    def add_sources(builder)
+        builder.add_source(CommandLineSource, :usage,
+                            "Usage: #{$0} [options] SRC_XML_FILE OUTPUT_FILE",
+                            "XmlToGdl can parse a guideline.xml file and generate GDL source code from it.",
+                            "If SRC_XML_FILE does not end with an xml extension, .xml will be added.")
+    end # def add_sources
+    
+    
+    def add_choices(builder)
+        # Arguments
+        builder.add_choice(:cmdArg, :length=>2) { |command_line|   # Use length to REQUIRE args.
+        #builder.add_choice(:cmdArg) { |command_line|
+            command_line.uses_arglist
+        }
+        
+        # Switches
+        builder.add_choice(:verbose, :type=>:boolean, :default=>false) { |command_line|
+            command_line.uses_switch("-v", "--verbose",
+                                    "Turn on verbose output.")
+        }
+        
+        # Options
+        builder.add_choice(:includes, :type=>[:string]) { |command_line|
+            command_line.uses_option("-i", "--includes ARG1[,ARG2,ARG3,ARGn]",
+                                    "Include external variable definition files.",
+									"Seperate multiple files with a comma (NO SPACES).")
+        }
+        
+    end # def add_choices
+    
+    
+    # Execute the XmlToGdl application.
+    # This method is called automatically when 'xmltogdl(.rb)' is executed from the command line.
+    def execute
+      $LOG.debug "XmlToGdlApp::execute"
+
+      if(@user_choices[:includes])
+        @user_choices[:includes].each do |inc|
+			@controller.addInclude(inc)
+		end
+      end
+      
+      if(@user_choices[:verbose])
+        @controller.setVerbose(@user_choices[:verbose])
+      end
+      
+      if(@user_choices[:cmdArg].empty?) # If no cmd line arg...
+        @controller.noCmdLineArg()
+        return
+      end
+      
+      result = @controller.setFilenames(@user_choices[:cmdArg])
+      
+      @controller.doSomething()
+    end # def execute
+        
+    
+end # class XmlToGdlApp
+
+
+#if $0 == __FILE__
+    XmlToGdlApp.new.execute
+#end    
+

data/docs/README.txt

@@ -0,0 +1,20 @@
+XmlToGdl README
+===============
+
+XlmToGdl consists of the following files:
+
+bin/xmlToGdl.rb	- Main()
+
+lib/xmlToGdl.rb - project lib include file
+
+lib/xmlToGdl/gdlDocBuilder.rb
+lib/xmlToGdl/contextListener.rb
+lib/xmlToGdl/contextParser.rb
+
+	ContextParser 
+		parses the raw XML file into the CtxListener (context object).
+		parses the context using:
+			GdlListener
+			RuleListener
+
+	

data/lib/xmlutils/contextlistener.rb

@@ -0,0 +1,432 @@
+#
+#	File: contextListener.rb
+#
+#	This class is used to convert XML to GDL
+#	
+#
+
+require 'rexml/streamlistener'
+require 'xmlutils/gdlcontext'
+require 'xmlutils/gdlcontextobjs'
+require 'xmlutils/listener'
+
+include REXML
+
+
+
+
+#################################################
+#
+# class ContextListener
+#
+#################################################
+class ContextListener < Listener
+	
+  attr_reader :context
+  attr_writer :curRuleset
+  attr_writer :curLookup
+
+  attr_writer :curParam
+  
+  attr_writer :inMsg
+
+
+
+
+
+	def initialize(ctx)
+		super()
+		@context 		= ctx
+		@curRuleset	= nil
+		@curLookup 	= nil
+		@curParam 	= nil
+		@curMsg			= nil
+		
+		@inMsg			= false
+		
+	end
+	
+
+
+
+  def inMsg?
+    return @inMsg
+  end
+	
+
+
+
+  def processingRuleset?
+    return true unless (nil == @curRuleset)
+    return false
+  end
+	
+
+
+
+  def processingLookup?
+    return true unless (nil == @curLookup)
+    return false
+  end
+	
+
+
+
+  def isXParam?
+    return true unless ('X' != @curParam)
+    return false
+  end
+	
+
+
+
+  def isYParam?
+    return true unless ('Y' != @curParam)
+    return false
+  end
+
+
+
+	
+#-------------------------------------------------------------------------------------------------------------#
+# cdata - A cdata node has been parsed
+#  Called when <![CDATA[ � ]]> is encountered in a document. @p content "�"
+# txt	- node text
+#------------------------------------------------------------------------------------------------------------#
+	def cdata(txt)
+		if (inMsg?)
+			raise "Message object has not yet been created." if (nil == @curMsg)
+			@curMsg.msg = txt
+			
+		end # if inMsg
+	end
+
+
+
+
+#-------------------------------------------------------------------------------------------------------------#
+# openDPM - Add a DPM variable to the context object
+#
+# attributes	- DPM element attributes
+#
+#------------------------------------------------------------------------------------------------------------#
+	def openDPM(attributes)
+		dpmAlias 	= attributes["Name"]
+		confName 	= @context.createValidName(dpmAlias)
+#		varType  	= attributes["Type"]
+#		dataType	= attributes["DataType"] if attributes.has_key?("DataType")
+#		prodType	= attributes["ProductType"]
+#
+#		dataType = prodType if nil == dataType
+#		
+#		dpm = Dpm.new(confName, dpmAlias, varType, dataType, prodType)
+		dpm = Dpm.new(confName, attributes)
+		
+		@context.dpms[dpmAlias] = dpm
+		
+		if (processingLookup?)
+			addLookupParam(dpm)
+		end
+		
+	end	# openDPM
+	
+
+
+
+#-------------------------------------------------------------------------------------------------------------#
+# openPPM - Add a PPM variable to the context object
+#
+# attributes	- PPM element attributes
+#
+#------------------------------------------------------------------------------------------------------------#
+	def openPPM(attributes)
+		ppmAlias 	= attributes["Name"]
+		confName 	= "p" + @context.createValidName(ppmAlias)
+#		varType  	= attributes["Type"]
+#		dataType	= attributes["DataType"] if attributes.has_key?("DataType")
+
+#		dataType = "Text" if nil == dataType
+		
+#		ppm = Ppm.new(confName, ppmAlias, varType, dataType)
+		ppm = Ppm.new(confName, attributes)
+		
+		@context.ppms[ppmAlias] = ppm
+
+		if (processingLookup?)
+			addLookupParam(ppm)
+		end
+		
+	end	# openPPM
+
+
+
+
+#-------------------------------------------------------------------------------------------------------------#
+# openRule - Add a rule to the context object
+#
+# attributes	- rule element attributes
+#
+#------------------------------------------------------------------------------------------------------------#
+	def openRule(attributes)
+		ruleAlias = attributes["Name"]
+		confName = @context.createValidName(ruleAlias)
+		
+		rule = Rule.new(confName, ruleAlias)
+		
+		@context.rules[ruleAlias] = rule
+		
+		@curRuleset.addRule(ruleAlias) if (processingRuleset?)
+		
+	end	# openRule
+	
+
+
+#-------------------------------------------------------------------------------------------------------------#
+# openRuleset - Open a ruleset object
+#
+# attributes	- ruleset element attributes
+#
+#------------------------------------------------------------------------------------------------------------#
+	def openRuleset(attributes)
+		if (processingRuleset?)
+			closeRuleset
+		end	# if
+		
+		rs = Ruleset.new(attributes)
+		rs.name = @context.createValidName(rs.alias)
+		
+		@curRuleset = rs
+		
+	end	# openRuleset
+	
+
+
+#-------------------------------------------------------------------------------------------------------------#
+# closeRuleset - Close a ruleset object
+#
+#
+#------------------------------------------------------------------------------------------------------------#
+	def closeRuleset()
+		if (processingRuleset?)
+			rsAlias = @curRuleset.alias
+			@context.rulesets[rsAlias] = @curRuleset
+		end	# if
+
+		@curRuleset = nil		
+		
+	end	# closeRuleset
+	
+
+
+#-------------------------------------------------------------------------------------------------------------#
+# openMessage - A Message element has been started
+#
+# name				- Tag name of unknown element
+# attributes	- Message element attributes
+#
+#------------------------------------------------------------------------------------------------------------#
+	def openMessage(attributes)
+		if ($DEBUG)
+			puts "openMessage"
+
+			if(!attributes.empty?)
+				puts "      Attr:"
+				attributes.each do |attr|
+					puts "            #{attr[0]}: #{attr[1]}"
+				end
+			end
+		end # if $DEBUG
+		
+		if (inMsg?)
+			closeMessage()
+		end # if inMsg
+		
+		@inMsg = true
+		
+		@curMsg = Message.new(attributes)
+		
+	end	# openMessage
+
+
+
+
+#-------------------------------------------------------------------------------------------------------------#
+# closeMessage - A Message element has been ended
+#
+# name				- Tag name of unknown element
+#
+#------------------------------------------------------------------------------------------------------------#
+	def closeMessage()
+		puts "closeMessage" if $DEBUG
+		if (inMsg?)
+			msgDone(@curMsg)			# Close out the msg
+			@curMsg = nil
+			@inMsg = false
+		end	# if inMsg
+	end	# closeMessage
+
+
+
+
+#-------------------------------------------------------------------------------------------------------------#
+# msgDone - A message is finished. Handle it by putting it in the If que or the Else que
+#
+# msg		  - Complete Message object
+#
+#------------------------------------------------------------------------------------------------------------#
+	def msgDone(msg)
+		puts "msgDone" if $DEBUG
+
+		if (msg.msg == nil || msg.msg.length < 1)
+			#raise "Blank message text. Unable to store message in context."
+			puts "Blank message text. Unable to store message in context."
+			return
+		end # if msg blank
+		
+		@context.messages[msg.msg] = msg
+		
+		puts msg.inspect if $DEBUG
+	end	# msgDone
+
+
+
+
+#-------------------------------------------------------------------------------------------------------------#
+# openLOOKUP - A LOOKUP element has been started
+#
+# attributes	- LOOKUP element attributes
+#
+#------------------------------------------------------------------------------------------------------------#
+	def openLOOKUP(attributes)
+		if (processingLookup?)
+			closeLOOKUP
+		end	# if
+		
+		lk = Lookup.new(attributes)
+		
+		@curLookup = lk
+		
+	end	# openLOOKUP
+
+
+
+
+#-------------------------------------------------------------------------------------------------------------#
+# closeLOOKUP - A LOOKUP element has been ended
+#
+#
+#------------------------------------------------------------------------------------------------------------#
+	def closeLOOKUP()
+		if (processingLookup?)
+			lkName = @curLookup.name
+			@context.lookups[lkName] = @curLookup
+		end	# if
+
+		@curLookup = nil		
+		
+	end	# closeUnknown
+
+
+
+
+#-------------------------------------------------------------------------------------------------------------#
+# addLookupParam - A LOOKUP parameter element has been ended
+#
+#
+#------------------------------------------------------------------------------------------------------------#
+	def addLookupParam(var)
+		if (processingLookup?)
+			if (isXParam?)
+				@curLookup.xParam = var
+			end
+			
+			if (isYParam?)
+				@curLookup.yParam = var
+			end
+			
+		end	# if
+
+	end	# addLookupParam
+
+
+
+
+#-------------------------------------------------------------------------------------------------------------#
+# openXParameter - A XParameter element has been started
+#
+# attributes	- XParameter element attributes
+#
+#------------------------------------------------------------------------------------------------------------#
+	def openXParameter(attributes)
+		@curParam = "X"
+	end	# openXParameter
+
+
+
+
+#-------------------------------------------------------------------------------------------------------------#
+# closeXParameter - A XParameter element has been ended
+#
+#
+#------------------------------------------------------------------------------------------------------------#
+	def closeXParameter()
+		@curParam = ""
+	end	# closeUnknown
+
+
+
+
+#-------------------------------------------------------------------------------------------------------------#
+# openYParameter - A YParameter element has been started
+#
+# attributes	- YParameter element attributes
+#
+#------------------------------------------------------------------------------------------------------------#
+	def openYParameter(attributes)
+		@curParam = "Y"
+	end	# openYParameter
+
+
+
+
+#-------------------------------------------------------------------------------------------------------------#
+# closeYParameter - A YParameter element has been ended
+#
+#
+#------------------------------------------------------------------------------------------------------------#
+	def closeYParameter()
+		@curParam = ""
+	end	# closeYParameter
+
+
+
+
+#-------------------------------------------------------------------------------------------------------------#
+# openXmlFunction - A XmlFunction element has been started
+#
+# attributes	- XmlFunction element attributes
+#
+#------------------------------------------------------------------------------------------------------------#
+	def openXmlFunction(attributes)
+		@curParam = "Y"
+	end	# openXmlFunction
+
+
+
+
+#-------------------------------------------------------------------------------------------------------------#
+# closeXmlFunction - A XmlFunction element has been ended
+#
+#
+#------------------------------------------------------------------------------------------------------------#
+	def closeXmlFunction()
+		@curParam = ""
+	end	# closeXmlFunction
+
+
+
+
+end	# class ContextListener
+
+
+