parse_decision 0.0.5

data/lib/parse_decision/plugin/product.rb

@@ -0,0 +1,176 @@
+##############################################################################
+# 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
+
+  ## #######################################################################
+  # Product info plugin
+  class Product < Plugin
+    attr_reader :data
+
+    def initialize()
+      $LOG.debug "Product::initialize"
+      @fnameTemplate  = "@INDEX@-@PROD@-PRODUCT.xml"
+      @searchStr1   = "<PRODUCTS><PRODUCT"
+      @searchStr2   = "<PARAMS><_DATA_SET"
+
+      @ruleStartStr   = "<Rules>"
+      @gdlStartStr  = "<Decision GuidelineId"
+      @stopStr    = "</Decision>"
+
+      @data       = []
+      @openTag    = "<@TAG@_DATA>\n"
+      @closeTag   = "</@TAG@_DATA>\n"
+      @openTag    = "<PRODUCT_DATA>\n"
+      @closeTag   = "</PRODUCT_DATA>\n"
+      @lineCount    = 0
+      @chunkSize    = 1000
+      @product    = ""
+
+      set_outfile( "" )
+    end
+
+    def set_outfile( outfile )
+      @outfile = outfile
+    end
+
+    def execute(context, ln)
+        #$LOG.debug "Product::execute"
+
+      case context.state
+      when :app
+        return accept_as_product_data context, ln
+
+      when :productXml
+        return accept_product_ppms context, ln
+
+      when :productPpms
+        return accept_product_rules context, ln
+
+      when :productRules
+        return process_product_rules context, ln
+
+      else
+        return false
+
+      end # case
+    end
+
+    def accept_as_product_data(context, ln)
+      if ln.include?(@searchStr1)
+        context.state = :productXml
+        @data.clear
+        set_outfile( "" )
+
+        # Generate the name of the output file
+        match = ln.match /\sName="([^"]+)/
+        product = "UnkProduct"
+        if(match && match.length > 1)
+          product = match[1]
+        end
+        @product = context.createValidName(product)
+        set_outfile( apply_templates(@fnameTemplate, {"@INDEX@"=>context.indexStr, "@PROD@"=>@product}) )
+
+        @data << ln
+
+        create_data_file context
+
+        @data.clear
+        return true
+      end
+
+      return false
+    end
+
+    def create_data_file(context)
+      puts "Creating product file: #{@outfile}" if context.verbose
+      File.open(context.outputPath(@outfile), "w") do |f|
+        write_to_file(f,@openTag)
+
+        # Write the product PPM's Xpath (which was stored in the context)
+        write_to_file(f,context[:productXpath] ) if ! context[:productXpath].nil?
+
+        write_to_file(f,@data)
+      end
+    end
+
+    def accept_product_ppms(context, ln)
+      if ln.include?(@searchStr2)
+        context.state = :productPpms
+
+        # XML Tidy doesn't like underscores at the beginning attribute names, take care of it here.
+        ln.gsub!(/_DATA_SET/, "DATA_SET")
+        ln.gsub!(/_Name/, "Name")
+        ln.gsub!(/_Value/, "Value")
+
+        @data << ln
+        return true
+      end
+    end
+
+    def accept_product_rules(context, ln)
+      if( ln.include?(@ruleStartStr) || ln.include?(@gdlStartStr) )
+        context.state = :productRules
+
+        @data << ln
+        return true
+      end
+    end
+
+    def process_product_rules(context, ln)
+      if !ln.include?(@stopStr)
+        @data << ln
+        @lineCount += 1
+
+        write_data_chunk context
+
+        return true
+      else
+
+        @data << ln
+        @lineCount += 1
+
+        close_out_data_file context
+        context.state = :app
+
+        return true
+      end
+    end
+
+    def write_data_chunk(context)
+      if(@lineCount > @chunkSize)
+        puts "Writing rule data chunk." if context.verbose
+        File.open(context.outputPath(@outfile), "a") do |f|
+          write_to_file(f,@data)
+        end
+        @lineCount = 0
+        @data.clear
+      end
+    end
+
+    def close_out_data_file(context)
+      puts "Closing product file #{@outfile}." if context.verbose
+      File.open(context.outputPath(@outfile), "a") do |f|
+        write_to_file(f,@data)
+        write_to_file(f,@closeTag)      # apply_template(@closeTag, "@TAG@", context.createValidName(@product))
+      end
+      @lineCount = 0
+      @data.clear
+    end
+
+  end # class Product
+
+
+end # module Plugin
+
+end # module ParseDecision

data/lib/parse_decision/plugin/product_xpath.rb

@@ -0,0 +1,52 @@
+##############################################################################
+# 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
+
+  ## #######################################################################
+  # Product XPath plugin
+  class ProductXpath < Plugin
+    def initialize()
+        $LOG.debug "ProductXpath::initialize"
+      @searchStr1 = "*PRODUCT XPATH xml*"
+      @searchStr2 = "<PPXPATH>"
+    end
+
+    def execute(context, ln)
+        #$LOG.debug "ProductXpath::execute"
+      if((context.state == :app) && ln.include?(@searchStr1))
+        context.state = :productXpath
+        return true
+      end
+
+      if((context.state == :productXpath) && ln.include?(@searchStr2))
+        context.state = :app
+        # We just store the product xpath in the context so it can
+        # be incorporated into the product rules file later.
+        context[:productXpath] = ln
+        return true
+      end
+
+      if(context.state == :productXpath)
+        # Probably a blank line. Claim it so we don't waste anyone else's time.
+        return true
+      end
+
+      return false
+    end
+  end # class ProductXpath
+
+
+end # module Plugin
+
+end # module ParseDecision

data/lib/parse_decision/plugin/web_product.rb

@@ -0,0 +1,179 @@
+##############################################################################
+# 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
+
+  ## #######################################################################
+  # Product info plugin - specific to webdecisions
+  class WebProduct < Plugin
+    attr_reader :data
+
+    def initialize()
+        $LOG.debug "WebProduct::initialize"
+      @fnameTemplate  = "@INDEX@-@PROD@-PRODUCT.xml"
+
+      @ruleStartStr   = "<Rules>"
+      @gdlStartStr  = "<Decision GuidelineId"
+      @stopStr    = "</Decision>"
+
+      @openProgramNameDpm = '>'
+      @closeProgramNameDpm = '</DPM>'
+
+
+      @data       = []
+      @outfile    = ""
+      @openTag    = "<@TAG@_DATA>\n"
+      @closeTag   = "</@TAG@_DATA>\n"
+      @openTag    = "<PRODUCT_DATA>\n"
+      @closeTag   = "</PRODUCT_DATA>\n"
+      @lineCount    = 0
+      @chunkSize    = 1000
+      @product    = ""
+      @productIndex = 1
+      @appIndex   = "00"
+
+    end
+
+    def productIndexStr()
+      return "%02d" % @productIndex
+    end
+
+
+    def execute(context, ln)
+        #$LOG.debug "WebProduct::execute"
+      if((context.state == :app) && ln.include?(@ruleStartStr))
+        context.state = :gdlRules
+        @data.clear
+        @outfile = ""
+        context["programNameFound"] = false
+        context["productName"]    = ""
+
+        if(!@appIndex.eql?(context.indexStr))
+          @productIndex = 1
+          @appIndex = context.indexStr
+        end
+
+        product = "Product" + productIndexStr()
+        @productIndex += 1
+        @product = context.createValidName(product)
+        @outfile = apply_templates(@fnameTemplate, {"@INDEX@"=>context.indexStr, "@PROD@"=>@product})
+        puts "" if context.verbose
+        puts "- + - + - + -" if context.verbose
+        puts "" if context.verbose
+        puts "Creating product file: #{@outfile}" if context.verbose
+        @data << ln
+        File.open(context.outputPath(@outfile), "w") do |f|
+          write_to_file(f,@openTag)     # apply_template(@openTag, "@TAG@", context.createValidName(@product))
+          write_to_file(f,context[:productXpath]) if ! context[:productXpath].nil?
+          write_to_file(f,@data)
+        end
+        @data.clear
+        return true
+      end
+
+      if((context.state == :gdlRules))
+        context.state = :productRules
+
+        @data << ln
+        return true
+      end
+
+      if((context.state == :productRules) && !ln.include?(@stopStr))
+        if(ln.include?("----"))       # Skip comment lines (they are not valid XML).
+          commentLine = ln.slice(0,4)
+          return true if(commentLine.include?("----"))
+        end
+
+        @data << ln
+        @lineCount += 1
+
+        if(!context["programNameFound"])
+          if(ln.include?('Name="Program Name"'))
+            productName = getSubString(ln, @openProgramNameDpm, @closeProgramNameDpm)
+            context["programNameFound"] = true
+            context["productName"] = productName
+            puts "........Program Name DPM found: #{productName}" if context.verbose
+
+          end # if ln.include?
+        end # if !context["programNameFound"]
+
+        if(@lineCount > @chunkSize)
+          puts "Writing rule data chunk." if context.verbose
+          File.open(context.outputPath(@outfile), "a") do |f|
+            write_to_file(f,@data)
+          end
+          @lineCount = 0
+          @data.clear
+        end
+        return true
+      end
+
+      if((context.state == :productRules) && ln.include?(@stopStr))
+        @data << ln
+        @lineCount += 1
+
+        puts "Closing product file." if context.verbose
+        File.open(context.outputPath(@outfile), "a") do |f|
+          write_to_file(f,@data)
+          write_to_file(f,@closeTag)    # apply_template(@closeTag, "@TAG@", context.createValidName(@product))
+        end
+        @lineCount = 0
+        @data.clear
+        context.state = :app
+        #@productIndex = 1
+
+        if(context["programNameFound"])
+          pname = context.createValidName(context["productName"])
+          newFileName = apply_templates(@fnameTemplate, {"@INDEX@"=>context.indexStr, "@PROD@"=>pname})
+
+          renameFile(context, @outfile, newFileName)
+        end # if context["programNameFound"]
+
+        context["programNameFound"] = false
+
+        return true
+      end
+
+      return false
+    end
+
+
+    def getSubString(haystack, startDelim, stopDelim)
+        #$LOG.debug "WebProduct::getSubString( #{haystack}, #{startDelim}, #{stopDelim} )"
+        #puts "WebProduct::getSubString()" # #{haystack}, #{startDelim}, #{stopDelim} )"
+        #puts "    haystack: #{haystack}"
+        #puts "  startDelim: #{startDelim}"
+        #puts "   stopDelim: #{stopDelim}"
+
+      start   = haystack.index(startDelim)
+        #puts "       start: " + (start.nil? ? "nil" : "#{start}")
+      return if start.nil?
+
+      start += startDelim.size
+      stop  = haystack.rindex(stopDelim)
+
+      res   = haystack[start,(stop - start)]
+    end # getSubString
+
+
+    def renameFile(context, srcFileName, destFileName)
+      puts "Renaming #{srcFileName} => #{destFileName}" if context.verbose
+      FileUtils.mv(context.outputPath(srcFileName), context.outputPath(destFileName))
+    end # renameFile
+
+
+  end # class WebProduct
+
+end # module Plugin
+
+end # module ParseDecision

data/lib/parse_decision/plugin.rb

@@ -0,0 +1,50 @@
+##############################################################################
+# 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
+##############################################################################
+
+#############################################################
+#   Stage Change Flow
+#
+# default mode:
+#   :app
+#     :appPpmXpath
+#       :preDecisionGdl
+#         :productXpath
+#           :productXml
+#             :productPpms
+#               :productRules
+#
+# webdecision mode:
+#   :app
+#     :gdlRules
+#       :productRules
+#         :decisionResponse
+#           :preDecisionGdl
+#
+#
+#
+#
+#############################################################
+
+
+##############################################################################
+module ParseDecision
+
+##############################################################################
+  module Plugin
+
+  end # module Plugin
+end # module ParseDecision
+
+require_relative 'plugin/plugin'
+require_relative 'plugin/application'
+require_relative 'plugin/ppm_xpath'
+require_relative 'plugin/pre_decision_guideline'
+require_relative 'plugin/product'
+require_relative 'plugin/product_xpath'
+require_relative 'plugin/web_product'

data/lib/parse_decision/version.rb

@@ -0,0 +1,5 @@
+module ParseDecision
+  VERSION = "0.0.5" unless constants.include?("VERSION")
+  APPNAME = "ParseDecision" unless constants.include?("APPNAME")
+  COPYRIGHT = "Copyright (c) 2014, kTech Systems LLC. All rights reserved" unless constants.include?("COPYRIGHT")
+end

data/lib/parse_decision.rb

@@ -0,0 +1,59 @@
+##############################################################################
+# File:: parse_decision.rb
+# Purpose:: Include file for ParseDecision library
+#
+# Author::    Jeff McAffee 03/12/2010
+# Copyright:: Copyright (c) 2010, kTech Systems LLC. All rights reserved.
+# Website::   http://ktechsystems.com
+##############################################################################
+
+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
+
+$LOGGING = false
+# Uncomment line below to force logging:
+#$LOGGING = true   # TODO: Change this flag to false when releasing production build.
+
+require "#{File.join( File.dirname(__FILE__), 'parse_decision','version')}"
+require "#{File.join( File.dirname(__FILE__), 'parse_decision','config')}"
+
+logcfg = ParseDecision::Config.new.load
+if(logcfg.key?(:logging) && (true == logcfg[:logging]) )
+  $LOGGING = true
+end
+
+if($LOGGING)
+  # Create a new log file each time:
+  file = File.open('parse_decision.log', File::WRONLY | File::APPEND | File::CREAT | File::TRUNC)
+  $LOG = Logger.new(file)
+  $LOG.level = Logger::DEBUG
+  #$LOG.level = Logger::INFO
+else
+  if(File.exists?('parse_decision.log'))
+FileUtils.rm('parse_decision.log')
+end
+end
+$LOG.info "**********************************************************************"
+$LOG.info "Logging started for ParseDecision library."
+$LOG.info "**********************************************************************"
+
+
+class_files = File.join( File.dirname(__FILE__), 'parse_decision', '*.rb')
+$: << File.join( File.dirname(__FILE__), 'parse_decision')  # Add directory to the include file array.
+Dir.glob(class_files) do | class_file |
+    require class_file[/\w+\.rb$/]
+end
+
+

data/parse_decision.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'parse_decision/version'
+
+Gem::Specification.new do |spec|
+  spec.platform      = Gem::Platform::RUBY
+  spec.name          = "parse_decision"
+  spec.version       = ParseDecision::VERSION
+  spec.authors       = ["Jeff McAffee"]
+  spec.email         = ["jeff@ktechsystems.com"]
+  spec.description   = %q{AMS Decision Log Parser}
+  spec.summary       = %q{AMS Decision Log Parser}
+  spec.homepage      = "https://github.com/jmcaffee/parse_decision"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec-given"
+  spec.add_development_dependency "pry"
+  spec.add_runtime_dependency "ktcommon"
+end

data/rakefile.rb

@@ -0,0 +1,58 @@
+######################################################################################
+# File:: rakefile
+# Purpose:: Build tasks for ParseDecision application
+#
+# Author::    Jeff McAffee 03/12/2010
+# Copyright:: Copyright (c) 2010, kTech Systems LLC. All rights reserved.
+# Website::   http://ktechsystems.com
+######################################################################################
+
+require 'bundler/gem_tasks'
+require 'psych'
+gem 'rdoc', '>= 3.9.4'
+
+require 'rake'
+require 'rake/clean'
+require 'rdoc/task'
+
+
+# Set the project name
+PROJNAME        = "ParseDecision"
+
+
+#############################################################################
+RDoc::Task.new(:rdoc) do |rdoc|
+    files = ['README.rdoc', 'docs/**/*.rdoc', 'lib/**/*.rb', 'bin/**/*']
+    rdoc.rdoc_files.add( files )
+    # Page to start on
+    rdoc.main = "README.md"
+  #puts "PWD: #{FileUtils.pwd}"
+    rdoc.title = "#{PROJNAME} Documentation"
+    rdoc.rdoc_dir = 'doc'                   # rdoc output folder
+    rdoc.options << '--line-numbers' << '--all'
+end
+
+
+
+#############################################################################
+desc "Run all tests"
+task :test => [:init] do
+  unless File.directory?('test')
+    $stderr.puts 'no test in this package'
+    return
+  end
+  $stderr.puts 'Running tests...'
+  TESTDIR = "test"
+  begin
+    require 'test/unit'
+  rescue LoadError
+    $stderr.puts 'test/unit cannot loaded.  You need Ruby 1.8 or later to invoke this task.'
+  end
+
+  $LOAD_PATH.unshift("./")
+  $LOAD_PATH.unshift(TESTDIR)
+  Dir[File.join(TESTDIR, "*.rb")].each {|file| require File.basename(file) }
+  require 'minitest/autorun'
+end
+
+

data/spec/context_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe ParseDecision::PDContext do
+
+  let(:context) { ParseDecision::PDContext.new }
+
+  it "throws an exception if invalid target state is requested" do
+    expect { context.state = :notAValidState }.to raise_error("Invalid target state: notAValidState")
+  end
+
+  Given(:target_dir) { 'spec/data' }
+  Given(:target_file) { 'testfile.txt' }
+
+  context "#src_file sets the source dir and file" do
+    When { context.src_file = File.join(target_dir, target_file) }
+
+    Then { context.srcdir.should eq target_dir }
+    Then { context.file.should eq target_file }
+  end
+
+end # describe ParseDecision::PDContext