parse_decision 0.0.5

data/lib/parse_decision/parser.rb

@@ -0,0 +1,194 @@
+##############################################################################
+# File:: parser.rb
+# Purpose:: Main Model object for ParseDecision utility
+#
+# Author::    Jeff McAffee 03/12/2010
+# Copyright:: Copyright (c) 2010, kTech Systems LLC. All rights reserved.
+# Website::   http://ktechsystems.com
+##############################################################################
+
+require 'ktcommon/ktpath'
+require 'ktcommon/ktcmdline'
+require 'parse_decision/plugin'
+require 'pathname'
+
+      #$LOG.level = Logger::ERROR
+
+##############################################################################
+# Everything is contained in Module ParseDecision
+module ParseDecision
+
+  ##########################################################################
+  # The Parser class runs the show. This class is called by the controller object
+  class Parser
+
+
+    def initialize()
+      $LOG.debug "Parser::initialize"
+      @cfg = Config.new.load
+      @plugins = [Plugin::Application.new,
+            Plugin::PpmXpath.new,
+            Plugin::PreDecisionGuideline.new,
+            Plugin::ProductXpath.new,
+            Plugin::Product.new,
+            ]
+      @context = PDContext.new
+    end
+
+
+    # Return the application's version string.
+    def version()
+      return ParseDecision::VERSION
+    end
+
+
+    # Validate the configuration.
+    def validateCfg(cfg)
+
+      if(!(cfg.key?(:file) && (nil != cfg[:file])))
+        puts "Missing --file option."
+        return false
+      end
+      if(!(cfg.key?(:outdir) && (nil != cfg[:outdir])) )
+        puts "Missing --outdir option."
+        return false
+      end
+
+      @context.file     = cfg[:file]
+      @context.outdir   = cfg[:outdir]
+
+      if(cfg.key?(:srcdir) && cfg[:srcdir] != nil)
+        @context.srcdir = cfg[:srcdir]
+      end
+
+      if(cfg.key?(:verbose) && cfg[:verbose] != nil)
+        @context.verbose = cfg[:verbose]
+      end
+
+      return true
+
+    end
+
+
+    def parse(srcpath, destpath)
+      path = Pathname.new srcpath
+      destpath = Pathname.pwd if destpath.nil?
+      parseCfg({ file: path.basename.to_s,
+                 srcdir: path.dirname.to_s, outdir: destpath.to_s })
+    end
+
+    # Parse files based on the configuration.
+    def parseCfg(cfg)
+      $LOG.debug "Parser::parseCfg( cfg )"
+
+      if( !validateCfg(cfg) )
+        puts "ERROR: Invalid options."
+        return
+      end
+
+      if( !File.exists?(@context.file) )
+        @context.file = File.join( @context.srcdir, @context.file )
+        if( !File.exists?(@context.file) )
+          puts "ERROR: unable to locate src file: #{@context.file}"
+          return
+        end
+      end
+
+      if( !File.exists?(@context.outdir) )
+        FileUtils.mkdir_p( @context.outdir )
+        puts "Output dir created: #{@context.outdir}" if @context.verbose
+      end
+
+      parseFile(@context.file)
+
+      # Copy the decision log to the output dir.
+      FileUtils.cp(@context.file, @context.outdir)
+    end
+
+
+    # Parse an XML decision file.
+    def parseFile(fname)
+      $LOG.debug "Parser::parseFile( #{fname} )"
+      puts "Parsing file: #{fname}" if @context.verbose
+
+      # Determine the mode and configure plugins based on the file data.
+      configureForFileMode(fname)
+
+      line_count = 1
+      # Open the file and read line by line
+      df = File.open(fname).each do |ln|
+        puts line_count.to_s if $DEBUG
+        line_count += 1
+        @plugins.each do |plug|
+          puts "     --> #{plug.class}" if $DEBUG
+          break if ( true == plug.execute(@context, ln))
+        end # plugins.each
+      end # do file
+
+      puts "Lines parsed: #{line_count}" if @context.verbose
+    end
+
+
+    def configureForFileMode(fname)
+      $LOG.debug "Parser::configureForFileMode( #{fname} )"
+
+      mode = :default
+      fileTypeFound = false
+
+      # Open the file and read line by line looking for indications of which mode to use.
+      df = File.open(fname).each do |ln|
+        # Search for 'normal' decision file.
+        if(ln.include?("<PARAMS>"))
+          fileTypeFound = true
+          puts "Decision file type = :default (not webdecision)" if @context.verbose
+          break
+        end
+
+        # Search for web decision file.
+        if(ln.include?("Next Decision"))
+          fileTypeFound = true
+          mode = :webdecision
+          puts "Decision file type = :webdecision" if @context.verbose
+          break
+        end
+
+        # Exit file search if mode has been determined.
+        if(true == fileTypeFound)
+          break
+        end
+      end # do file
+
+      # If the file is a web decision, reset the plugins.
+      if(mode == :webdecision)
+        @context.parseMode = mode
+        @plugins = [Plugin::Application.new,
+              Plugin::WebProduct.new,
+              ]
+
+      end
+    end
+
+
+    def parseFileWithSwitch(arg)
+      $LOG.debug "Parser::parseFileWithSwitch( #{arg} )"
+    end
+
+
+    def parseFileWithCmdLineArg(arg)
+      $LOG.debug "Parser::parseFileWithCmdLineArg( #{arg} )"
+    end
+
+    # Set directory where generated files are placed.
+    def setOutdir(dir)
+      @context.outdir = dir
+    end
+
+    def noCmdLineArg()
+      $LOG.debug "Parser::noCmdLineArg"
+    end
+
+
+  end # class Parser
+
+
+end # module ParseDecision

data/lib/parse_decision/pd_context.rb

@@ -0,0 +1,148 @@
+##############################################################################
+# File:: pd_context.rb
+# Purpose:: Context object used by all plugins
+#
+# Author::    Jeff McAffee 03/12/2010
+# Copyright:: Copyright (c) 2010, kTech Systems LLC. All rights reserved.
+# Website::   http://ktechsystems.com
+##############################################################################
+
+require 'ktcommon/ktpath'
+require 'ktcommon/ktcmdline'
+require 'parse_decision/plugin'
+require 'pathname'
+
+      #$LOG.level = Logger::ERROR
+
+##############################################################################
+# Everything is contained in Module ParseDecision
+module ParseDecision
+
+  ##########################################################################
+  # Context class holds all info and state about the current parsing process
+  class PDContext
+
+    attr_reader :outdir
+    attr_reader :srcdir
+    attr_reader :file
+    attr_reader :verbose
+    attr_reader :index
+    attr_reader :state
+    attr_reader :parseMode
+
+
+    def initialize()
+        $LOG.debug "PDContext::initialize"
+      @outdir   = nil
+      @srcdir   = "."
+      @file   = nil
+      @verbose  = false
+      @index    = 0
+      @parseMode  = :default  # :webdecision
+      @data   = nil   # Hash to store plugin data in
+
+      @availableStates = {}
+      @availableStates[:default]    = [:app, :appPpmXpath, :preDecisionGdl, :productXpath, :productXml, :productPpms, :productRules, ]
+      @availableStates[:webdecision]  = [:app, :gdlRules, :productRules, :decisionResponse, :preDecisionGdl, ]
+    end
+
+
+    # Return the data hash, creating it if needed.
+    def data()
+      @data ||= {}
+    end
+
+
+    # Return data from hash.
+    def [](sym)
+      return data[sym]
+    end
+
+
+    # Return data from hash.
+    def []=(sym, val)
+      return data[sym] = val
+    end
+
+
+    # Return array of current available states.
+    def availableStates()
+      return @availableStates[@parseMode]
+    end
+
+
+    # Set the parse mode.
+    def parseMode=(mode)
+      @parseMode = mode if [:default, :webdecision].include?(mode)
+    end
+
+
+    # Set the output dir path.
+    def outdir=(dir)
+      @outdir = File.rubypath(dir) unless nil == dir
+    end
+
+
+    # Set source file and dir path
+    def src_file=(file)
+      fp = Pathname.new(file)
+      @srcdir = fp.dirname.to_s
+      @file = fp.basename.to_s
+    end
+
+    # Set the source dir path.
+    def srcdir=(dir)
+      @srcdir = File.rubypath(dir) unless nil == dir
+    end
+
+
+    # Set the name of file to parse.
+    def file=(filename)
+      @file = File.rubypath(filename) unless nil == filename
+    end
+
+
+    # Turn on verbose mode.
+    def verbose=(verbose)
+      @verbose = verbose
+    end
+
+
+    # Return the full output path including the filename.
+    def outputPath(filename)
+      raise "outdir missing" unless !@outdir.nil?
+      outputPath = File.join(@outdir, filename)
+    end
+
+
+    def state=(nextState)
+      raise "Invalid target state: #{nextState.to_s}" unless availableStates.include? nextState
+
+      @state = nextState
+      puts "STATE: #{nextState.to_s}" if $DEBUG
+    end
+
+    def nextIndex()
+      @index += 1
+    end
+
+    def indexStr()
+      return "%03d" % @index
+    end
+
+
+    def createValidName(inname)
+      return nil if nil == inname
+
+      outname = inname.gsub(/[\s\/\\?*#+]/,'')        # Remove illegal chars (replace with underscore).
+      outname.gsub!(/_+/,"_")                 # Replace consecutive uscores with single uscore.
+      outname.gsub!(/\./,"-")                 # Replace period with dash.
+      outname.gsub!(/[\(\)\$]/,"")              # Remove L & R Parens, dollar signs.
+      outname.gsub!(/\%/,"Perc")                # Replace '%' with Perc.
+
+      outname
+    end
+  end
+
+
+end # module ParseDecision

data/lib/parse_decision/plugin/application.rb

@@ -0,0 +1,48 @@
+##############################################################################
+# File:: plugin.rb
+# Purpose:: Plugin objects for ParseDecision utility
+#
+# Author::    Jeff McAffee 04/17/2010
+# Copyright:: Copyright (c) 2010, kTech Systems LLC. All rights reserved.
+# Website::   http://ktechsystems.com
+##############################################################################
+
+##############################################################################
+module ParseDecision
+
+##############################################################################
+module Plugin
+
+  ## #######################################################################
+  # Application XML plugin
+  class Application < Plugin
+    def initialize()
+      $LOG.debug "Application::initialize"
+      @fnameTemplate = "@INDEX@-APP.xml"
+      @searchStr = "<DECISION_REQUEST><APPLICATION"
+      @searchStr = "<APPLICATION "            # Note that the space at end is required.
+    end
+
+    def execute(context, ln)
+     #$LOG.debug "Application::execute"
+      if(ln.include?(@searchStr))
+        context.nextIndex
+        context.state = :app
+        outfile = apply_template(@fnameTemplate, "@INDEX@", context.indexStr)
+        puts "" if context.verbose
+        puts "= = = = = = = = = = = = = = = = = = = = = = = = = = = =" if context.verbose
+        puts "" if context.verbose
+        puts "Creating Application XML file: #{outfile}" if context.verbose
+        File.open(context.outputPath(outfile), "w") do |f|
+          write_to_file(f,ln)
+        end
+        return true
+      end
+      return false
+    end
+  end # class Application
+
+
+end # module Plugin
+
+end # module ParseDecision

data/lib/parse_decision/plugin/plugin.rb

@@ -0,0 +1,56 @@
+##############################################################################
+# File:: plugin.rb
+# Purpose:: Plugin objects for ParseDecision utility
+#
+# Author::    Jeff McAffee 04/17/2010
+# Copyright:: Copyright (c) 2010, kTech Systems LLC. All rights reserved.
+# Website::   http://ktechsystems.com
+##############################################################################
+
+##############################################################################
+module ParseDecision
+
+##############################################################################
+module Plugin
+
+  ## #######################################################################
+  # Base class for all plugins
+  class Plugin
+    def initialize()
+      $LOG.debug "Plugin::initialize"
+    end
+
+    def apply_template(template, pattern, replacement)
+      output = template.gsub(pattern, replacement)
+    end
+
+    def apply_templates(template, repPatterns)
+      output = template
+      repPatterns.each do |p,r|
+        output = output.gsub(p, r)
+      end # repPatterns.each
+      output
+    end
+
+    def execute(context, ln)
+     $LOG.debug "Plugin::execute"
+      return false
+    end
+
+    def write_to_file(f,data)
+      if(data.class == Array)
+        data.each do |ln|
+          f.write ln
+        end
+      else
+        f.write data
+      end
+    end
+
+
+  end # class Plugin
+
+
+end # module Plugin
+
+end # module ParseDecision

data/lib/parse_decision/plugin/ppm_xpath.rb

@@ -0,0 +1,70 @@
+##############################################################################
+# File:: plugin.rb
+# Purpose:: Plugin objects for ParseDecision utility
+#
+# Author::    Jeff McAffee 04/17/2010
+# Copyright:: Copyright (c) 2010, kTech Systems LLC. All rights reserved.
+# Website::   http://ktechsystems.com
+##############################################################################
+
+##############################################################################
+module ParseDecision
+
+##############################################################################
+module Plugin
+
+  ## #######################################################################
+  # PPM XPath plugin
+  class PpmXpath < Plugin
+    def initialize()
+      $LOG.debug "PpmXpath::initialize"
+      @fnameTemplate = "@INDEX@-APP-PPMXPATH.xml"
+      @searchStr1 = "*APP XPATH xml*"
+      @searchStr2 = "<PPXPATH>"
+    end
+
+    def execute(context, ln)
+     #$LOG.debug "PpmXpath::execute"
+     #require 'pry'; binding.pry
+     case context.state
+     when :app
+       return is_ppm_xpath context, ln
+
+     when :appPpmXpath
+       return store_xpath_content context, ln
+
+     else
+       return false
+     end # case
+    end
+
+    def is_ppm_xpath(context,ln)
+      if ln.include?(@searchStr1)
+        context.state = :appPpmXpath
+        return true
+      end
+      return false
+    end
+
+    def store_xpath_content(context, ln)
+      if ln.include?(@searchStr2)
+        context.state = :app
+        outfile = apply_template(@fnameTemplate, "@INDEX@", context.indexStr)
+        puts "Creating App XML XPath file: #{outfile}" if context.verbose
+        File.open(context.outputPath(outfile), "w") do |f|
+          write_to_file(f,ln)
+        end
+        return true
+      end
+
+      # This is probably an empty line.
+      # Return true since we're in the xpath state and there is no need for
+      # any other plugin to handle this line.
+      return true
+    end
+  end # class PpmXpath
+
+
+end # module Plugin
+
+end # module ParseDecision

data/lib/parse_decision/plugin/pre_decision_guideline.rb

@@ -0,0 +1,177 @@
+##############################################################################
+# File:: plugin.rb
+# Purpose:: Plugin objects for ParseDecision utility
+#
+# Author::    Jeff McAffee 04/17/2010
+# Copyright:: Copyright (c) 2010, kTech Systems LLC. All rights reserved.
+# Website::   http://ktechsystems.com
+##############################################################################
+
+##############################################################################
+module ParseDecision
+
+##############################################################################
+module Plugin
+
+  ## #######################################################################
+  # Pre-Decision Guideline XML plugin
+  class PreDecisionGuideline < Plugin
+
+    attr_reader :ppmData
+    attr_reader :outfile
+
+    def initialize()
+      $LOG.debug "PreDecisionGuideline::initialize"
+      @fnameTemplate    = "@INDEX@-@GDL@-Rules.xml"
+      @searchStrPpms    = "<PARAMS><_DATA_SET"
+      @searchStrGdl     = "<Guideline "
+      @searchStrGdl2    = "******Guideline*"
+      @searchStrGdlEnd  = "<Decision GuidelineId"
+      @searchRulesEnd   = "</Decision>"
+      @ppmData      = ""
+      @ruleData     = []
+
+      @openTag      = "<@TAG@_DATA>\n"
+      @closeTag     = "</@TAG@_DATA>\n"
+      @actualCloseTag = ""
+      @lineCount    = 0
+      @chunkSize    = 1000
+      @outfile      = "PreDecision"
+    end
+
+    def execute(context, ln)
+      #$LOG.debug "PreDecisionGuideline::execute"
+
+      case context.state
+      when :app
+        return check_for_ppms_or_rule_start context, ln
+
+      when :preDecisionGdl
+        return process_rule_data context, ln
+
+      else
+        return false
+      end # case
+    end
+
+    def check_for_ppms_or_rule_start(context, ln)
+      if ln.include?(@searchStrPpms)
+        @ppmData = ln
+        # XML Tidy doesn't like underscores at the beginning attribute names, take care of it here.
+        @ppmData.gsub!(/_DATA_SET/, "DATA_SET")
+        @ppmData.gsub!(/_Name/, "Name")
+        @ppmData.gsub!(/_Value/, "Value")
+        return true
+      end
+
+      if ln.include?(@searchStrGdl) || ln.include?(@searchStrGdl2)
+        context.state = :preDecisionGdl
+        @ruleData.clear
+        open_discard_element
+        @ruleData << ln
+        return true
+      end
+
+      return false
+    end
+
+    def open_discard_element
+      # The log can contain a lot of junk here. This prevents it from being a valid
+      # XML doc. To account for this, we'll create a DISCARD element for easy folding
+      # and put everything into an HTML comment block.
+
+      # We need to track when discarding is on, so we only turn it off once.
+      @discarding = true
+
+      @ruleData << "<DISCARD_BY_PARSER>\n"
+      @ruleData << "<!-- "   # The leading element tag is not valid XML (no quotes around attrib params).
+    end
+
+    def close_discard_element
+      # Only output the closing element if discarding is actually on.
+      # This could get called multiple times after discarding has been turned off.
+      if !@discarding.nil? && @discarding
+        @discarding = false
+        @ruleData << "-->\n"   # The leading element tag is not valid XML (no quotes around attrib params).
+        @ruleData << "</DISCARD_BY_PARSER>\n"
+      end
+    end
+
+    def process_rule_data(context, ln)
+      # Create the rules data file if the Guideline end tag is found
+      if ln.include?(@searchStrGdlEnd)
+        close_discard_element
+        setup_rules_file context, ln
+        return true
+      end
+
+      # Close the rules data file if the rules end tag is found
+      if ln.include?(@searchRulesEnd)
+        close_out_rules_file context, ln
+        context.state = :app
+        return true
+      end
+
+      # Haven't found the start or end of the rules here,
+      # we must be somewhere in the middle.
+      # Store the data so it can be written to file later.
+      write_rules_data context, ln
+
+      return true
+    end
+
+    def setup_rules_file(context, ln)
+      @ruleData << ln
+
+      # Default guideline name
+      gdlName = "PreDecision"
+
+      # String#match acts weird so using RegEx/MatchData here.
+      m = /\sGuidelineName="([^"]+)/.match(ln)
+      if m[1].length > 1
+        gdlName = m[1]
+        gdlName = context.createValidName(gdlName)
+      end
+
+      @outfile = apply_templates(@fnameTemplate, {"@INDEX@"=>context.indexStr, "@GDL@"=>gdlName})
+
+      # Store the closing tag for later.
+      @actualCloseTag = apply_template(@closeTag, "@TAG@", gdlName)
+
+      puts "Creating Gdl Rules file: #{@outfile}" if context.verbose
+
+      File.open(context.outputPath(@outfile), "w") do |f|
+        write_to_file(f, apply_template(@openTag, "@TAG@", gdlName))
+        write_to_file(f,@ppmData)
+      end
+    end
+
+    def close_out_rules_file(context, ln)
+      @ruleData << ln
+
+      File.open(context.outputPath(@outfile), "a") do |f|
+        write_to_file(f,@ruleData)
+        write_to_file(f, @actualCloseTag)
+      end
+    end
+
+    def write_rules_data(context, ln)
+      @ruleData << ln
+      @lineCount += 1
+
+      if(@lineCount > @chunkSize)
+        puts "Writing rule data chunk." if context.verbose
+        File.open(context.outputPath(@outfile), "a") do |f|
+          write_to_file(f,@ruleData)
+        end
+        @lineCount = 0
+        @ruleData.clear
+      end
+    end
+    
+  end # class PreDecisionGuideline
+
+
+end # module Plugin
+
+end # module ParseDecision