winexcel 0.0.1

data/lib/winexcel/excel_file/common_methods.rb

@@ -0,0 +1,422 @@
+# excel_file.rb
+#
+#     File based on Xls.rb being part of 'wwatf' project
+#     Copyright (C) 2010-2011 Sobieraj Kamil <ksob@dslowl.com>.
+#
+# This file is published under New BSD License
+# You can redistribute and/or 
+# modify it under the terms of the New BSD License.
+#
+# New BSD License claims:
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+#      this list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#      this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# 3. Neither the name of Zend Technologies USA, Inc. nor the names of its
+#      contributors may be used to endorse or promote products derived from this
+#      software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+require 'logger'
+require 'win32ole'
+
+require 'rubygems'
+if RUBY_VERSION >= '1.9'
+  require 'win32olerot'
+else
+  require 'winexcel/win32olerot_ext/win32olerot'
+end
+
+
+# Excel interface class.
+# This class provides many simple methods for using Excel spreadsheets.
+#
+# Inner working:
+# If the File is already open in excel, data is read from the open file 
+# and left open after the call to the close/finalize method.
+# If the file is not open, It will be opened in the background 
+# and closed when the close/finalize method is called.
+#
+# For examples look at the examples folder as well as Cucumber/RSpec 
+# files in features and spec directories
+#
+# Information for developers:
+#   It is helpful to use COM/Win32OLE tracking tool like "oakland ActiveX Inspector"
+#   to clearly see what Excel instances are beeing created
+#
+module WinExcel
+
+  class ExcelFile
+
+    #returns a 2D Array representing the given range of Data stored in a given worksheet
+    #Note: All contiguious ranges are supported, however, only non-contigious column sellections of equal size are accepted.
+    # *myRange* can either be a string representing a range: "A1:C4", a named range defined in the workbook: "SomeNamedRange", or the text in a cell "myRangeing" a contigious table of values below it. If it is nil or not specified the CurrentRegion starting at "A1" is used.
+    #
+    #EXAMPLE DATA:
+    #           A                        B                      C
+    #  1        ID                   name		            nickname
+    #  2       001                Fredrick White		  fred
+    #  3       002	             Robert Green	        bob
+    #RETURNS:
+    # Calling get2DArray("A1:C3") would return the following 2D array
+    #  [[ID, name, nickname],
+    #   [001, Fredrick White, fred],
+    #   [002, Robert Green, bob]]
+    def get2DArray(myRange=nil, sheet=nil, enableCaching=false)
+      if myRange != nil and myRange.instance_of?(String)
+        if myRange.match(/^[A-Za-z]+$/)
+          worksheet = getWorksheet(sheet)
+          row_min = worksheet.UsedRange.Row
+          row_max = row_min + worksheet.UsedRange.Rows.Count - 1
+          myRange = myRange + row_min.to_s + ':' + myRange + row_max.to_s
+        end
+
+        if enableCaching
+          $ExcelCache ||= {}
+          if myRange != nil and myRange.instance_of?(String)
+            cacheKey = @workbook.Name.gsub(/\s+/, "").upcase + sheet.to_s + myRange.to_s
+          end
+        end
+      end
+
+      data = nil
+      if enableCaching and $ExcelCache[cacheKey]
+        data = $ExcelCache[cacheKey]
+      else
+        @log.info("get2DArray(myRange=#{myRange}, sheet = #{sheet}")
+
+        if myRange == nil or myRange.instance_of?(String)
+          myRange = getRange(myRange, sheet)
+          if myRange == nil
+            return nil
+          end
+        end
+        data = []
+        areas = []
+
+        #Deal with non-contigious regions by looping through each region.
+        myRange.Areas.each do |area|
+          areas << area.value #get the data from each area
+        end
+
+        numRecords = myRange.Rows.Count
+        (0..numRecords-1).each do |i|
+          record=[]
+          areas.each do |area|
+            if (area.kind_of? Array)
+              record.concat(area[i])
+            else
+              record << area
+            end
+          end
+          #Clean up formatting
+          record.collect! do |x|
+            if x.is_a?(Float) and x % 1 == 0
+              x.to_i.to_s
+            else
+              x.to_s.strip # need to_s.strip to get realword.
+            end
+          end
+          data << record
+        end
+
+        # save it to global cache
+        $ExcelCache[cacheKey] = data if enableCaching
+      end
+
+      return data.clone
+    end
+
+    class ExcelCell
+      attr_accessor :addr, :val
+    end
+
+    def getVisibleUsed2DArray(sheet=nil, offsetTolerance=5)
+      worksheet = getWorksheet(sheet)
+      if worksheet == nil
+        return nil
+      end
+
+      offsetTolerance = 30
+      contents = []
+      records = []
+      rowOffset = 0
+      maxOccupiedColCnt = 0
+      worksheet.UsedRange.Rows.each do |row|
+        record = []
+        colOffset = 0
+        isRowEmpty = true
+        row.Cells.each do |cell|
+          if cell.HasFormula or cell.Rows.Hidden or cell.Columns.Hidden
+            next
+          end
+          xlsCell = ExcelCell.new
+          xlsCell.addr = cell.Address
+          xlsCell.val = cell.Value.to_s.strip
+          if xlsCell.val.empty? then
+            colOffset = colOffset.succ
+            if colOffset > offsetTolerance + maxOccupiedColCnt then
+              break
+            end
+          else
+            isRowEmpty = false
+            colOffset = 0
+          end
+
+          record << xlsCell
+        end
+
+        if record.length > maxOccupiedColCnt then
+          maxOccupiedColCnt = record.length
+        end
+
+        if record.empty? then
+          next
+        elsif isRowEmpty then
+          rowOffset = rowOffset.succ
+          if rowOffset > offsetTolerance then
+            break
+          end
+        else
+          rowOffset = 0
+          records << record
+        end
+      end
+
+      return records
+    end
+
+
+    #Searches for the first occurance of *myRange* on *sheet* and returns the address of the range representing the contigious set of cells below(xlDown) and to the right(xlRight) of *myRange*
+    #If *sheet* is not specified, the first sheet is used.
+    # *myRange* can either be a string representing a range: "A1:C4", a named range defined in the workbook: "SomeNamedRange", or the text in a cell "myRangeing" a contigious table of values below it.
+    # If it is nil or not specified the CurrentRegion starting at "A1" is used.
+    def getRange(myRange="", sheet=nil)
+      @log.info(self.class) { "getRange(myRange=#{myRange}, sheet=#{sheet}" }
+      worksheet = getWorksheet(sheet)
+      if worksheet == nil
+        return nil
+      end
+      #find where the data is
+      if myRange.nil? or myRange == ""
+        #rng=worksheet.Range("A1").CurrentRegion
+        rng = worksheet.UsedRange
+        rng = worksheet.Range("A1:#{rng.Address.split(':')[1]}")
+      else
+        begin
+          #use myRange as an excel range if it is one
+          rng = worksheet.Range(myRange)
+        rescue WIN32OLERuntimeError #must not be a standard excel range...  look for the myRange.
+          rng = worksheet.Range("A1", worksheet.UsedRange.SpecialCells(11)).Find(myRange) #xlCellTypeLastCell
+          raise "getRange(myRange=#{myRange}, sheet=#{sheet}) --> Could not locate range via specified myRange." unless rng
+          rng = rng.Offset(1)
+          rng = worksheet.Range(rng, rng.End(-4121)) #-4121 --> xlDown
+          rng = worksheet.Range(rng, rng.End(-4161)) #-4161  --> xlToRight
+        end
+      end
+
+      return rng
+    end
+
+
+    def getWorksheetCount()
+      return @workbook.Worksheets.Count
+    end
+
+    def getAllWorksheets()
+      return @workbook.Worksheets
+    end
+
+    def getWorksheet(sheet=nil)
+      if sheet.nil?
+        worksheet = @workbook.Worksheets(1)
+        if worksheet then
+          @log.info("getWorksheet(sheet=#{sheet}) --> #{worksheet.Name}")
+        end
+        return worksheet
+      elsif sheet.instance_of?(Regexp)
+        @workbook.Worksheets.each do |s|
+          if s.Name.upcase.match(sheet)
+            if s.Visible == 0 then
+              return nil
+            end
+            return s
+          end
+        end
+      elsif sheet.instance_of?(String)
+        @workbook.Worksheets.each do |s|
+          if s.Name.gsub(/\s+/, '').upcase == sheet.gsub(/\s+/, '').upcase
+            if s.Visible == 0 then
+              return nil
+            end
+            return s
+          end
+        end
+        #puts "Could not find sheet #{sheet} in #{@workbook.Name}" if @workbook.Name
+      else
+        return sheet
+      end
+    end
+
+    def getWorksheets(visibleOnly=true)
+      if not visibleOnly then
+        return @workbook.Worksheets
+      end
+      arrWorksheets = []
+      @workbook.Worksheets.each do |s|
+        if s.Visible != 0 then
+          arrWorksheets << s
+        end
+      end
+      return arrWorksheets
+    end
+
+
+    #Closes Workbook if it was opened.
+    def closeWorkbookOnly(forceClose=false)
+      if forceClose or not @connectedToOpenWorkBook
+        @workbook.Close(false) # false for not to save changes
+        @log.info(self.class) { "Workbook Closed" }
+      end
+    end
+
+    def close(forceClose=false)
+      closeWorkbookOnly(forceClose)
+    end
+
+
+    #writes out the 2D Array *data* starting at the specified range *myRange* on the specified sheet
+    def write2DArrayAtOnce(data, myRange, sheet = nil)
+      @log.info("write2DArray(data='...',myRange='#{myRange}', sheet = '#{sheet})'")
+      worksheet = getWorksheet(sheet)
+      #get the actual excel range object
+      myRange = worksheet.Range(myRange)
+
+
+      # find maximum row length (or column quantity) for the 'data' array,
+      # it would be column quantity of 2D array if we would put the 'data' array into one
+      maxWidth = 0
+      maxCellLength = 0
+      data.each do |row|
+        maxWidth = row.length if maxWidth < row.length
+        row.each do |cell|
+          maxCellLength = cell.to_s.length if cell and maxCellLength < cell.to_s.length
+        end
+      end
+      data.collect do |row|
+        while row.length < maxWidth
+          if not row.kind_of? Array
+            row = []
+          end
+          row << ''
+        end
+      end
+      if maxCellLength < 8204
+        myRange.Resize(data.length, maxWidth).Value = data if data and data.length > 0
+      else
+        (0..data.length-1).each do |row|
+          (0..data[row].length-1).each do |col|
+            myRange.Offset(row, col).value = data[row][col]
+          end
+        end
+      end
+
+
+    end
+
+
+    def appendWorksheet(name, visible = true)
+      sheet = @workbook.Worksheets.Add('After' => @workbook.Worksheets(@workbook.Worksheets.Count))
+      sheet.Name = name
+      sheet.Cells.NumberFormat = "@"
+      sheet.Visible = 0 if not visible
+    end
+
+    #appends the 2D Array *data* starting at the first empty row on the specified sheet.
+    def append2DArrayAtOnce(data, sheet = nil)
+      @log.info("append2DArray(data='...', sheet = '#{sheet})'")
+      worksheet = getWorksheet(sheet)
+      throw "append2DArray method cannot find '#{sheet}' sheet" if not worksheet
+      row_min = worksheet.UsedRange.Row
+      row_max = row_min + worksheet.UsedRange.Rows.Count - 1
+      col_min = worksheet.UsedRange.Column
+      col_max = col_min + worksheet.UsedRange.Columns.Count - 1
+      firstEmptyRow = row_max + 1
+      write2DArrayAtOnce(data, "A#{firstEmptyRow}", sheet)
+    end
+
+    #appends the 2D Array *data* starting at the first empty row on the specified sheet.
+    def append2DArray(data, sheet = nil)
+      @log.info("append2DArray(data='...', sheet = '#{sheet})'")
+      worksheet = getWorksheet(sheet)
+      throw "append2DArray method cannot find '#{sheet}' sheet" if not worksheet
+      row_min = worksheet.UsedRange.Row
+      row_max = row_min + worksheet.UsedRange.Rows.Count - 1
+      col_min = worksheet.UsedRange.Column
+      col_max = col_min + worksheet.UsedRange.Columns.Count - 1
+      firstEmptyRow = row_max + 1
+      write2DArray(data, "A#{firstEmptyRow}", sheet)
+    end
+
+
+    def setDisplayAlerts(val=true)
+      @excel.DisplayAlerts = val
+    end
+
+    #Saves the current workbook.
+    def save
+      setDisplayAlerts(false)
+      begin
+        @workbook.Save
+      rescue
+        @excel.Save
+      end
+    end
+
+
+    def worksheetExists?(sheet)
+      @workbook.Sheets(sheet).Name != ""
+    end
+
+    #Saves as the current workbook.
+    def saveAs(fileName)
+      @workbook.SaveAs(fileName.gsub("/", "\\"))
+    end
+
+    def setVisible(val=true)
+      @excel.Visible = val
+    end
+
+    def setInteractive(val=true)
+      @excel.Interactive = val
+    end
+
+    def setScreenUpdating(val=true)
+      @excel.ScreenUpdating = val
+    end
+
+    def setDisplayAlerts(val=true)
+      @excel.DisplayAlerts = val
+    end
+
+  end
+
+end

data/lib/winexcel/excel_file/other_methods.rb

@@ -0,0 +1,315 @@
+# excel_file.rb
+#
+#     File based on Xls.rb being part of 'wwatf' project
+#     Copyright (C) 2010-2011 Sobieraj Kamil <ksob@dslowl.com>.
+#
+# This file is published under New BSD License
+# You can redistribute and/or 
+# modify it under the terms of the New BSD License.
+#
+# New BSD License claims:
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+#      this list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#      this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+#
+# 3. Neither the name of Zend Technologies USA, Inc. nor the names of its
+#      contributors may be used to endorse or promote products derived from this
+#      software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+require 'logger'
+
+module WinExcel
+
+  class ExcelFile
+
+    module Range
+      CHARS_IN_ALPHABET = 26
+      SEPARATOR = ':'
+    end
+
+
+    #Given row and column number, returns Excel-formatted range
+    #e.g.
+    #given: row=5, column=4
+    #returns: "D5"
+    def self.toExcelRange(row, column)
+      unless (row > 0 and column > 0)
+        raise ArgumentError.new("Row and column should be positive numbers; given: row=#{row}, column=#{column}.")
+      end
+
+      columnName = ''
+      begin
+        column -= 1
+        column, rest = column.divmod(Range::CHARS_IN_ALPHABET)
+        columnName = (?A + rest).chr + columnName
+      end while column > 0
+
+      return columnName + row.to_s
+    end
+
+    def self.toExcelCompoundRange(rangeBegin, rangeEnd)
+      return (rangeBegin + Range::SEPARATOR + rangeEnd)
+    end
+
+
+    #
+    #  Protect method as it applies to the Worksheet object.
+    #  Protects a worksheet so that it cannot be modified.
+    #
+    #  sheet.Protect(Password, DrawingObjects, Contents, Scenarios, UserInterfaceOnly, AllowFormattingCells,
+    #    AllowFormattingColumns, AllowFormattingRows, AllowInsertingColumns, AllowInsertingRows, AllowInsertingHyperlinks,
+    #    AllowDeletingColumns, AllowDeletingRows, AllowSorting, AllowFiltering, AllowUsingPivotTables)
+    #
+    def protect(password="zx")
+      @workbook.Worksheets.each do |s|
+        s.Protect(
+            'Password' => password,
+            'DrawingObjects' => true,
+            'Contents' => true,
+            'Scenarios' => true,
+            'UserInterFaceOnly' => true,
+            'AllowFormattingCells' => true,
+            'AllowFormattingColumns' => true,
+            'AllowFormattingRows' => true,
+            'AllowInsertingColumns' => false,
+            'AllowInsertingRows' => false,
+            'AllowInsertingHyperlinks' => false,
+            'AllowDeletingColumns' => false,
+            'AllowDeletingRows' => false,
+            'AllowSorting' => true,
+            'AllowFiltering' => true,
+            'AllowUsingPivotTables' => true
+        )
+      end
+    end
+
+    def unprotect(password="zx")
+      @workbook.Worksheets.each do |s|
+        s.Unprotect(password)
+      end
+    end
+
+
+    def find(expr, sheet, alphaNumOnly=true)
+      if records[sheet].nil?
+        records[sheet] = getVisibleUsed2DArray(sheet)
+      end
+      hpExpr = expr.human_proof(alphaNumOnly)
+      hpExpr = Regexp.escape(hpExpr)
+      hpExpr = hpExpr.gsub("\\*", '.*')
+      hpExpr = /\A#{hpExpr}\Z/
+      records[sheet].each_with_index do |record, ri|
+        record.each_with_index do |cell, ci|
+          if hpExpr.match(cell.val.human_proof(alphaNumOnly))
+            return [ri, ci, cell.val]
+          end
+        end
+      end
+
+      return nil
+    end
+
+    ##
+    # Find an expression/text using standard excel find dialog
+    #
+    def findDialog(expr, sheet=nil)
+
+      worksheet = getWorksheet(sheet)
+      if worksheet == nil
+        return nil
+      end
+
+      range = worksheet.Cells.Find('What' => expr,
+                                   'SearchDirection' => ExcelConst::XlNext,
+                                   'SearchOrder' => ExcelConst::XlByRows,
+                                   'LookIn' => ExcelConst::XlValues,
+                                   'LookAt' => ExcelConst::XlWhole)
+      # Other options:
+      # 	ExcelConst::XlPrevious,
+      #	ExcelConst::XlByColumns,
+      #	MatchCase => False,
+      #	After => ActiveCell,
+      return range
+    end
+
+
+    #Returns an array of hashes representing data records stored in rows in the given *myRange* and *sheet*.
+    # *myRange* can either be a string representing a range: "A1:C4", a named range defined in the workbook: "SomeNamedRange", or the text in a cell "myRangeing" a contigious table of values below it. If it is nil or not specified the CurrentRegion starting at "A1" is used.
+    #Note: *myRange* should include headers, and may contain non-contigious column ranges of equal size
+    #EXAMPLE DATA:
+    #           A                        B                      C
+    #  1        ID                   name		            nickname
+    #  2       001                Fredrick White		  fred
+    #  3       002	             Robert Green	        bob
+    #
+    #Standard Range example:
+    # getRowRecords("A1:C3") would return the following array of hashes:
+    #  [  {'ID'=>'001', 'Name'=>'Fredrick White', 'Nickname'=>'fred'},
+    #     {'ID'=>'002', 'Name'=>'Robert Green', 'Nickname'=>'bob'}  ]
+    #
+    #Non-Contigious Range Example:
+    # getRowRecords("A1:A3,C1:C3") would return the following array of hashes:
+    #  [  {'ID'=>'001', 'Nickname'=>'fred'},
+    #     {'ID'=>'002', 'Nickname'=>'bob'}  ]
+    def getRowRecords(myRange, sheet = nil)
+      return convert2DArrayToArrayHash(get2DArray(myRange, sheet), true)
+    end
+
+
+    #Returns an array of hashes representing data records stored in rows in the given *myRange* and *sheet*.
+    # *myRange* can either be a string representing a range: "A1:C4", a named range defined in the workbook: "SomeNamedRange", or the text in a cell "myRangeing" a contigious table of values below it. If it is nil or not specified the CurrentRegion starting at "A1" is used.
+    #Note: *myRange* should include headers, and may contain non-contigious column ranges of equal size
+    #EXAMPLE DATA:
+    #           A                  B                           C
+    #  1        ID              001                          002
+    #  2       Name           Fredrick White		      Robert Green
+    #  3       NickName	   fred                         bob
+    #
+    #Standard Range Example:
+    # getColumnRecords("A1:C3") would return the following array of hashes:
+    #  [  {'ID'=>'001', 'Name'=>'Fredrick White', 'Nickname'=>'fred'},
+    #     {'ID'=>'002', 'Name'=>'Robert Green', 'Nickname'=>'bob'}  ]
+    def getColumnRecords(myRange, sheet = nil)
+      return convert2DArrayToArrayHash(get2DArray(myRange, sheet), false)
+    end
+
+    #Returns a hash of key-value pairs where the keys are pulled from column 1 and the values are pulled form column 2 of *myRange* on *sheet*.
+    # *myRange* can either be a string representing a range: "A1:C4", a named range defined in the workbook: "SomeNamedRange", or the text in a cell "labeling" a contigious table of values below it. If it is nil or not specified the CurrentRegion starting at "A1" is used.
+    #Note: ':'s are striped off of each key if they exist.
+    #EXAMPLE DATA:
+    #           A                  B
+    #  1        ID              001
+    #  2       Name:           Fredrick White
+    #  3       NickName:	   fred
+    #Example usage:
+    # getHashFromRange("A1:B3") would return the following hash:
+    #  {'ID'=>'001', 'Name'=>'Fredrick White', 'Nickname'=>'fred'}
+    def getHash(myRange = nil, sheet = nil, columnHeaders = false)
+      tmpHash = convert2DArrayToArrayHash(get2DArray(myRange, sheet), columnHeaders)[0]
+      newHash = CoreExt::OrderedHash.new
+      tmpHash.each do |key, value|
+        newHash[key.sub(/:/, '')] = value
+      end
+      return newHash
+    end
+
+
+    #*myArray* should either have column or row headers to use as keys.  columnHeader=false implies that there are row headers.
+    def convert2DArrayToArrayHash(myArray, columnHeaders=true)
+      myArray = myArray.transpose unless columnHeaders
+      arrayHash=[]
+      (1..myArray.length-1).each do |i|
+        rowHash = Hash.new #OrderedHash.new  #
+        (0..myArray[i].length-1).each do |j|
+          rowHash[myArray[0][j]] = myArray[i][j]
+        end
+        arrayHash << rowHash
+      end
+      return arrayHash
+    end
+
+
+    def convertArrayHashTo2DArray(myArrayHash)
+      @log.info(self.class) { "convertArrayHashTo2DArray(myArrayHash)" }
+      return [] if myArrayHash.empty?
+
+      my2DArray = []
+      #iterate through keys write out header row
+      myKeys = myArrayHash[0].keys
+      my2DArray << myKeys
+      #write out data
+      (0..myArrayHash.length-1).each do |row|
+        myRow = []
+        myKeys.each do |key|
+          myRow << myArrayHash[row][key]
+        end
+        my2DArray << myRow
+      end
+      return my2DArray
+    end
+
+    # Adds a new worksheet to workbook
+    def addSheet(sheetName)
+      @workbook.Sheets.Add
+      @workbook.ActiveSheet.Name = sheetName
+    end
+
+    # Deletes a worksheet from the workbook
+    def deleteSheet(sheetName = nil)
+      @excel.DisplayAlerts=false
+      sheet = getWorksheet(sheetName)
+      sheet.delete
+    end
+
+
+    def removeRowsWithSkipping(worksheet, rowsToSkip)
+      ur = worksheet.UsedRange.Rows.Count
+      start = rowsToSkip + 1
+      if ur >= start
+        myRange = "A#{start}:A#{ur}" #xlDown = -4121
+        range = worksheet.Range(myRange).EntireRow
+        range.Delete()
+      end
+    end
+
+
+    def write1DArrayColor(data, myRange, sheet = nil, col = 0)
+      @log.info(self.class) { "write2DArray(data='...',myRange='#{myRange}', sheet = '#{sheet})'" }
+      worksheet = getWorksheet(sheet)
+      #get the actual excel range object
+      myRange = worksheet.Range(myRange)
+      data.each_index do |row|
+        @log.debug(self.class) { data[row] }
+        myRange.Offset(row, col).Interior.Color = data[row]
+      end
+    end
+
+
+    #writes out the Array hash  *data* starting at the specified range *myRange* on the specified sheet.
+    #the keys are used as column headers starting at the specified range.
+    def writeArrayHash(data, myRange, sheet = nil)
+      @log.info(self.class) { "writeArrayHash(data='...',myRange='#{myRange}', sheet = '#{sheet})'" }
+      write2DArray(convertArrayHashTo2DArray(data), myRange, sheet)
+    end
+
+    #appends the 2D Array *data* starting at the first empty row on the specified sheet.
+    #the keys are used as column headers.
+    def appendArrayHash(data, sheet = nil)
+      @log.info(self.class) { "appendArrayHash(data='...', sheet = '#{sheet})'" }
+      data = convertArrayHashTo2DArray(data)
+      data.slice!(0)
+      append2DArray(data, sheet)
+    end
+
+    #outputs a 2DArray *myArray* to a CSV file specified by *file*.
+    def save2DArraytoCSVFile(myArray, file)
+      myFile = File.open(file, 'w')
+      @log.info(self.class) { "2DArraytoCSVFile(myArray=..., file=#{file})" }
+      (0..myArray.length-1).each do |i|
+        myFile.puts(myArray[i].join(',')) unless myArray[i].nil?
+      end
+      myFile.close
+    end
+
+  end
+
+end