ppmtogdl 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e982d83fb1d9f1f23a6806989b87cb86642d3ee0
+  data.tar.gz: 56c07cdbfe9e0bbab96e9e038503fc519cc047f8
+SHA512:
+  metadata.gz: bf58333bfc919b7e67fc376570bfcd8bfaa5eeddf7dac43790f62f91dff3dbd415e22238c1de2babc9e640952750b09407143f3050a417784eab313e5bf6af55
+  data.tar.gz: 2b5490cba9d00e246def90e61153301a6b08ed7ef38341602f55f2aa848ed081c40db6ec411c9a1763880e806887cc3b49066f6930d52d78c2217fa816688334

data/.gitignore

@@ -0,0 +1,6 @@
+# .gitignore
+pkg/
+buildgem
+buildgem.cmd
+Gemfile.lock
+test/data/*.yml

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in ppmtogdl.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,72 @@
+# PpmToGdl Documentation
+
+## Description
+
+PpmToGdl provides both a command line application and a rake task
+that is used to generate a .GDL file containing the PPMs parsed out
+of the PrimaryParameters.xml file.
+
+## Installation
+
+Add this line to your gemfile:
+
+    require 'ppmtogdl'
+
+And then execute:
+
+    $ bundle install
+
+or install it yourself as:
+
+    gem install ppmtogdl
+
+## Usage
+
+### Rake Task Usage
+
+The rake task can be included in a rakefile by requiring ppmtogdl like so:
+
+    require 'ppmtogdl'
+
+and called as:
+
+    PpmToGdlTask.new.execute( customer, srcPath, destPath )
+
+### Command Line Application
+
+Usage info can be retrieved from the application by calling it with the -h or --help
+options:
+
+    $ ppmtogdl --help
+
+
+### Notes
+
+* Using a parameter of `all` for customer will generate GDL for all PPMs in the file.
+
+## Testing
+
+PpmToGdl currently uses an outdated version of TestUnit for testing.
+Tests can be found in the `test` directory.
+
+## TODO
+
+Update method naming convention to ruby standards.
+
+## Contributing
+
+1. Fork it ( https://github.com/jmcaffee/ppmtogdl/fork )
+1. Clone it (`git clone git@github.com:[my-github-username]/ppmtogdl.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
+
+PpmToGdl is licensed under the MIT license.
+
+See [LICENSE](https://github.com/jmcaffee/ppmtogdl/blob/master/LICENSE) for
+details.
+

data/bin/ppmtogdl

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+##############################################################################
+# File:: ppmtogdl.rb
+# Purpose:: Utility to ...
+# 
+# Author::    Jeff McAffee 03/07/2010
+# Copyright:: Copyright (c) 2010, kTech Systems LLC. All rights reserved.
+# Website::   http://ktechsystems.com
+##############################################################################
+
+require 'ppmtogdl'
+require 'user-choices'
+
+include PpmToGdl
+
+class PpmToGdlApp < UserChoices::Command
+    include UserChoices
+
+    
+    def initialize()
+        super
+        @controller = PpmToGdlController.new
+    end
+    
+    
+    def add_sources(builder)
+        builder.add_source(CommandLineSource, :usage,
+                            "Usage: #{$0} [options] SRC_XML_FILE OUTPUT_FILE",
+                            "PpmToGdl can parse a PrimaryParameter.xml file and generate GDL ppm definitions 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(:customer, :type=>:string) { |command_line|
+            command_line.uses_option("-c", "--customer ARG",
+                                    "Only generate PPMs for XML elements containing ARG in customer attribute.")
+        }
+        
+    end # def add_choices
+    
+    
+    # Execute the PpmToGdl application.
+    # This method is called automatically when 'ppmtogdl(.rb)' is executed from the command line.
+    def execute
+      $LOG.debug "PpmToGdlApp::execute"
+
+      if(@user_choices[:customer])
+        @controller.customer = @user_choices[:customer]
+      end
+      
+      if(@user_choices[:verbose])
+        @controller.verbose = @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 PpmToGdlApp
+
+
+#if $0 == __FILE__
+    PpmToGdlApp.new.execute
+#end    

data/lib/ppmtogdl.rb

@@ -0,0 +1,39 @@
+##############################################################################
+# File:: ppmtogdl.rb
+# Purpose:: Include file for PpmToGdl library
+#
+# Author::    Jeff McAffee 03/07/2010
+#
+##############################################################################
+
+require 'find'
+require 'logger'
+require 'bundler/setup'
+
+if(!$LOG)
+  $LOG = Logger.new(STDERR)
+  $LOG.level = Logger::ERROR
+end
+
+if ENV["DEBUG"] == '1'
+  puts "LOGGING: ON due to DEBUG=1"
+  $LOG.level = Logger::DEBUG
+end
+
+$LOG.info "**********************************************************************"
+$LOG.info "Logging started for PpmToGdl library."
+$LOG.info "**********************************************************************"
+
+
+require_relative 'ppmtogdl/version'
+
+require_relative 'ppmtogdl/ppmcontextobjs'
+require_relative 'ppmtogdl/ppmcontext'
+require_relative 'ppmtogdl/ppmtogdlcfg'
+require_relative 'ppmtogdl/contextlistener'
+require_relative 'ppmtogdl/contextparser'
+require_relative 'ppmtogdl/gdldocbuilder'
+require_relative 'ppmtogdl/gdldoc'
+require_relative 'ppmtogdl/ppmtogdlcontroller'
+require_relative 'ppmtogdl/ppmtogdltask'
+

data/lib/ppmtogdl/contextlistener.rb

@@ -0,0 +1,43 @@
+##############################################################################
+# File::    contextlistener.rb
+# Purpose:: ContextListener 'listens' to the incoming xml steam and parses
+#           tokens out of the stream.
+#
+# Author::    Jeff McAffee 04/30/2015
+#
+##############################################################################
+
+require 'rexml/streamlistener'
+require 'xmlutils/listener'
+
+include REXML
+
+module PpmToGdl
+  class ContextListener < Listener
+
+    attr_reader :context
+
+    def initialize(ctx)
+    $LOG.debug "ContextListener::initialize()"
+      super()
+      @context    = ctx
+    end
+
+    # Add a PPM variable to the context object
+    # attributes:: PPM element attributes
+    def openPPM(attributes)
+    $LOG.debug "ContextListener::openPPM( #{attributes} )"
+
+      if(@context.options.has_key?("customer") && !@context.options["customer"].empty?)
+        return unless (attributes.has_key?("Customer") && attributes["Customer"].include?(@context.options["customer"]))
+      end
+      ppmAlias  = attributes["Name"]
+      confName  = "p" + @context.createValidName(ppmAlias)
+      ppm = MPpm.new(confName, attributes)
+
+      @context.ppms[ppmAlias] = ppm
+    end # openPPM
+  end # class ContextListener
+end # module PpmToGdl
+
+

data/lib/ppmtogdl/contextparser.rb

@@ -0,0 +1,78 @@
+##############################################################################
+# File::    contextparser.rb
+# Purpose:: ContextParser holds all info and state about the current parsing
+#           process. This class will convert XML guideline files to GDL
+#           (Guideline Definition Language).
+#
+# Author::    Jeff McAffee 04/30/2015
+#
+##############################################################################
+
+require 'rexml/document'
+require 'rexml/streamlistener'
+require 'xmlutils/dumplistener'
+
+module PpmToGdl
+  class ContextParser
+
+    attr_accessor :context
+
+    def initialize(ctx)
+    $LOG.debug "ContextParser::initialize()"
+      @context      = ctx
+      @verbose      = false
+    end
+
+    # Return true if verbose flag is set.
+    def verbose?()
+      return @verbose
+    end # verbose?
+
+    # Set configuration flags
+    # flg:: Array of options or single string option. Currently, only -v: verbose is available
+    def setFlag(flg)
+    $LOG.debug "ContextParser::setFlag( #{flg} )"
+      if (flg.class == Array)
+        flg.each do |f|
+          case f
+            when '-v'
+              @verbose = true
+          end
+        end # flg.each
+
+        return
+      end # if flg
+
+      case flg
+        when '-v'
+          @verbose = true
+      end
+    end
+
+    # Parse guideline XML
+    # fname:: Filename of XML file to parse
+    def parse(fname)
+    $LOG.debug "ContextParser::parse( #{fname} )"
+      puts "Parsing file." unless (!verbose?)
+      ctxListener         = ContextListener.new(@context)
+      ctxListener.verbose = @verbose
+      parser = Parsers::StreamParser.new(File.new(fname), ctxListener)
+      parser.parse
+
+=begin
+      puts "Parsing guideline." unless (!verbose?)
+      gdlListener         = GdlListener.new(@context)
+      gdlListener.verbose = @verbose
+      parser = Parsers::StreamParser.new(File.new(fname), gdlListener)
+      parser.parse
+=end
+    end # parse
+
+    # Dump collected context info to STDOUT
+    def dumpResults()
+    $LOG.debug "ContextParser::dumpResults()"
+      @listener.context.dumpPpms()
+    end # dumpResults
+  end # class ContextParser
+end # module PpmToGdl
+

data/lib/ppmtogdl/gdldoc.rb

@@ -0,0 +1,396 @@
+###############################################################################
+# File::    gdldoc.rb
+# Purpose:: GdlDoc describes a GDL source document. It is used to create
+#           the final source doc.
+#
+# Author::    Jeff McAffee 04/30/2015
+#
+##############################################################################
+
+require 'xmlutils/gdltemplate'
+require 'date'
+
+module PpmToGdl
+  class GdlDoc
+
+    attr_reader :context
+    attr_reader :srcPath
+
+    def initialize(srcPath, ctx)
+    $LOG.debug "GdlDoc::initialize( #{srcPath}, ctx )"
+      #super()
+      @srcPath      = srcPath
+      @context      = ctx
+    end
+
+  #------------------------------------------------------------------------------------------------------------#
+  # setOptions - Set configuration option flags
+  #
+  # flg - Array of options or single string option. Currently, only -v: verbose is available
+  #
+  #------------------------------------------------------------------------------------------------------------#
+    def setOptions(flgs)
+    $LOG.debug "GdlDoc::setOptions( #{flgs} )"
+      if (flgs.class == Array)
+        flgs.each do |f|
+          case f
+            when '-v'
+              @verbose = true
+          end
+        end # flgs.each
+
+        return
+      end # if flgs
+
+      case flgs
+        when '-v'
+          @verbose = true
+      end
+    end
+
+  #-------------------------------------------------------------------------------------------------------------#
+  # currentDate - Generate today's date string
+  #
+  #
+  #------------------------------------------------------------------------------------------------------------#
+    def currentDate()
+      now = DateTime::now()
+      return now.strftime("%m/%d/%Y %H:%M:%S")
+    end # currentDate
+
+  #-------------------------------------------------------------------------------------------------------------#
+  # generate - Generate a GDL document
+  #
+  # returns string - generated file name
+  #
+  #------------------------------------------------------------------------------------------------------------#
+    def generate()
+    $LOG.debug "GdlDoc::generate()"
+      destDir = @context.options[:destdir]
+      destFile = @context.options[:destfile]
+      if(nil == destFile || destFile.empty?)
+        destFile = File.basename(@srcPath, ".xml") + ".gdl"
+      end
+
+      #if ($DEBUG)
+        puts "generate:"
+        puts "   sourcePath: #{@srcPath}"
+        puts "      destDir: #{destDir}"
+        puts "     destFile: #{destFile}"
+        puts "      context: #{@context}"
+      #end # if $DEBUG
+
+      tpl = GdlTemplate.new
+
+      genFile = File.join(destDir, destFile)  # "#{@rootDir}/#{File.basename(@srcPath)}.gdl"
+
+      createOutdir(destDir)
+
+      misc = ""
+
+      if(@context.options.has_key?("customer") && !@context.options["customer"].empty?)
+        misc = "Using --customer option: #{@context.options['customer']}"
+      end
+
+      File.open("#{genFile}", "w") do |ofile|
+
+        ofile << tpl.fileHeader(destFile, currentDate(), misc )
+
+        ofile << tpl.sectionComment("PPM Definitions")
+
+        vars = @context.ppms.sort {|a, b| a[1].name.downcase <=> b[1].name.downcase}
+        vars.each do |rPpm|
+          ppm = rPpm[1]
+          ofile << tpl.ppm(ppm.dataType, ppm.varType, ppm.name, ppm.alias)
+        end # do
+
+      end # File.open
+
+      return genFile
+    end # generate
+
+  #-------------------------------------------------------------------------------------------------------------#
+  # generateRenameList - Generate a CSV rename list
+  #
+  # returns string - generated file name
+  #
+  #------------------------------------------------------------------------------------------------------------#
+    def generateRenameList()
+    $LOG.debug "GdlDoc::generateRenameList()"
+
+      if ($DEBUG)
+        puts "generateRenameList:"
+        puts "       source: #{@srcPath}"
+        puts "      rootDir: #{@rootDir}"
+        puts "      context: #{@context}"
+      end # if $DEBUG
+
+      genFile = "#{@rootDir}/#{@srcPath}.rename.csv"
+
+      createOutdir(@rootDir)
+
+      File.open("#{genFile}", "w") do |ofile|
+
+                                              # Don't add to list if alias has '.'.
+                                              # Don't add to list if alias and name are identical.
+        vars = @context.rules.sort {|a, b| a[0].downcase <=> b[0].downcase}
+        vars.each do |ruleAry|
+          rule = ruleAry[1]
+          if (ruleAry[0] != rule.name)
+            if (nil == ruleAry[0].index('.'))
+              ofile << "rule,#{ruleAry[0]},#{rule.name}\n"
+            end # if no period
+          end # if name and alias do not match
+        end # do
+
+                                              # Don't add to list if ruleset is powerlookup.
+                                              # Don't add to list if alias and name are identical.
+        vars = @context.rulesets.sort {|a, b| a[0].downcase <=> b[0].downcase}
+        vars.each do |rulesetAry|
+          ruleset = rulesetAry[1]
+          if ("PL" != ruleset.type)
+            if (rulesetAry[0] != ruleset.name)
+              ofile << "ruleset,#{rulesetAry[0]},#{ruleset.name}\n"
+            end # if not identical
+          end # if not PL ruleset
+        end # do
+      end
+
+      return genFile
+    end # generateRenameList
+
+  #-------------------------------------------------------------------------------------------------------------#
+  # buildLookupList - Create a listing of lookup definitions from the context
+  #
+  #
+  #------------------------------------------------------------------------------------------------------------#
+    def buildLookupList()
+    $LOG.debug "GdlDoc::buildLookupList()"
+      lkups = Hash.new
+      lkList = ""
+      tpl = GdlTemplate.new
+
+      @context.lookups.each do |lkName, lkup|
+        params = @context.getLookupParamNames(lkName)
+        lkups[lkName] = tpl.lookup(lkName, params["xparam"], params["yparam"])
+      end # do
+
+      sorted = lkups.sort {|a, b| a[0].downcase <=> b[0].downcase}
+      sorted.each do |item|
+        lkList += "#{item[1]};\n"
+      end # do sorted
+
+      return lkList
+    end # def buildLookupList
+
+  #-------------------------------------------------------------------------------------------------------------#
+  # createOutdir - Create a directory if it does not exist
+  #
+  # outdir  - Directory name/path to create
+  #
+  #------------------------------------------------------------------------------------------------------------#
+    def createOutdir(outdir)
+      if( !File.directory?(outdir) )
+        FileUtils.makedirs("#{outdir}")
+      end
+    end # def createOutdir
+
+  #-------------------------------------------------------------------------------------------------------------#
+  # outputFileHeader - output file header
+  #
+  # ofile   - output file to write header to
+  # infile  - Name of file to create header for
+  #
+  #------------------------------------------------------------------------------------------------------------#
+    def outputFileHeader(ofile, infile)
+      header = <<EOF
+/* **************************************************************************
+ * File: #{infile}.gdl
+ * Generated guideline
+ *
+ * *************************************************************************/
+
+
+EOF
+
+      ofile << header
+    end
+
+  #-------------------------------------------------------------------------------------------------------------#
+  # definitionHeader - output collected variables to file
+  #
+  # headerType  - Header type (ex: DSM)
+  #
+  #------------------------------------------------------------------------------------------------------------#
+    def definitionHeader(headerType)
+      header = <<EOF
+
+
+
+
+// ---------------------------- #{headerType} definitions ----------------------------
+
+EOF
+
+      header
+    end # def definitionHeader
+
+  #-------------------------------------------------------------------------------------------------------------#
+  # outputPpm - generate a GDL version of a PPM definition based on PPM XML element
+  #
+  # var - XML element to generate output for
+  #
+  # @returns  GDL output for PPM definition
+  #
+  #------------------------------------------------------------------------------------------------------------#
+    def outputPpm(var)
+    $LOG.debug "GdlDoc::outputPpm()"
+      xVarType = "text"
+      xvarSection = var.attribute('Type').to_s
+
+      case xvarSection
+        when 'APM'
+          varSection = "app"
+
+        when 'PRD'
+          varSection = "prd"
+
+        when 'CRP'
+          varSection = "crd"
+      end
+
+      varAlias = var.attribute('Alias')
+      varName = var.attribute('Name')
+
+      out = <<EOF
+  ppm #{xVarType} #{varSection} p#{varName}   "#{varAlias}";
+EOF
+
+      out                                               # Return generated output
+    end # outputPpm
+
+  #-------------------------------------------------------------------------------------------------------------#
+  # outputDsm - generate a GDL version of a DSM definition based on DSM XML element
+  #
+  # var - XML element to generate output for
+  #
+  # @returns  GDL output for DSM definition
+  #
+  #------------------------------------------------------------------------------------------------------------#
+    def outputDsm(var)
+    $LOG.debug "GdlDoc::outputDsm()"
+      xVarType = var.attribute('ProductType').to_s
+
+      case xVarType
+        when '1'
+          varType = "boolean"
+
+        when '2'
+          varType = "date"
+
+        when '3'
+          varType = "money"
+
+        when '4'
+          varType = "numeric"
+
+        when '5'
+          varType = "percentage"
+
+        when '6'
+          varType = "text"
+      end
+
+      varAlias = var.attribute('Alias')
+      varName = var.attribute('Name')
+
+      out = <<EOF
+decision    dpm #{varType}  #{varName}    "#{varAlias}";
+EOF
+
+      out                                               # Return generated output
+    end # outputDsm
+
+  #-------------------------------------------------------------------------------------------------------------#
+  # outputDpm - generate a GDL version of a DPM definition based on DPM XML element
+  #
+  # var - XML element to generate output for
+  #
+  # @returns  GDL output for DPM definition
+  #
+  #------------------------------------------------------------------------------------------------------------#
+    def outputDpm(var)
+    $LOG.debug "GdlDoc::outputDpm()"
+      xVarType = var.attribute('ProductType').to_s
+
+      case xVarType
+        when '1'
+          varType = "boolean"
+
+        when '2'
+          varType = "date"
+
+        when '3'
+          varType = "money"
+
+        when '4'
+          varType = "numeric"
+
+        when '5'
+          varType = "percentage"
+
+        when '6'
+          varType = "text"
+      end
+
+      varAlias = var.attribute('Alias')
+      varName = var.attribute('Name')
+
+      out = <<EOF
+  dpm #{varType}  #{varName}    "#{varAlias}";
+EOF
+
+      out                                               # Return generated output
+    end # outputDpm
+
+  #-------------------------------------------------------------------------------------------------------------#
+  # outputRuleInfo - output collected variables to file
+  #
+  # ofile - output file handle
+  #
+  #------------------------------------------------------------------------------------------------------------#
+    def outputRuleInfo(ofile)
+    $LOG.debug "GdlDoc::outputRuleInfo()"
+
+      ofile << definitionHeader("Rule")
+
+      @rules.each_value do |rule|
+        ofile << outputRule(rule)
+      end
+    end # def outputRuleInfo
+
+  #-------------------------------------------------------------------------------------------------------------#
+  # outputRule - generate a GDL version of a rule definition based on Rule XML element
+  #
+  # rule  - XML element to generate output for
+  #
+  # @returns  GDL output for Rule definition
+  #
+  #------------------------------------------------------------------------------------------------------------#
+    def outputRule(rule)
+    $LOG.debug "GdlDoc::outputRule()"
+      ruleParts = rule.elements.to_a
+      puts ""
+      puts "Rule Parts:"
+      puts "#{ruleParts.inspect}"
+      puts ""
+
+      visitor = XmlRuleVisitor.new
+      output = ""
+      visitor.lookupData = @lookupData
+
+      return visitor.visit(rule, output)
+    end # outputRule
+  end # class GdlDoc
+end # module PpmToGdl
+