rasta 0.1.8-x86-mswin32-60

data/lib/rasta/spreadsheet.rb

@@ -0,0 +1,528 @@
+
+module Rasta
+  module Spreadsheet
+    require 'logger'
+    require 'singleton'
+    
+    WORKING_DIR = Dir.getwd
+    
+    # Singleton Class to store Excel Constant Variables
+    class ExcelConst; include Singleton; end
+    
+    # Exceptions
+    class SheetNotFound < RuntimeError; end
+    class BookmarkNotFound < RuntimeError; end
+    
+    # Singleton Class to store Excel Instance
+    #
+    # :visible          Make the Excel Spreadsheet visible when processing
+    # :continue         Continue from a bookmark
+    # :pagecount        Continue for n pages after a bookmark
+    #
+    class Excel 
+      include Singleton
+      attr_reader :excel, :visible
+      attr_accessor :continue, :currentrecord, :currentpage, :pagecount, :recordcount
+      def initialize
+        @visible = false
+        @continue = false
+        @currentrecord = 0
+        @currentpage = 0
+        @pagecount = 0 
+        @recordcount = 0
+        @open_workbooks = []
+        @excel = WIN32OLE::new('excel.Application')
+        WIN32OLE.const_load(@excel, ExcelConst) if ExcelConst.constants == []    # load Excel constants
+      end
+      
+      def open(filename)
+        @excel.Workbooks.Open(File.expand_path(filename))
+      end
+      
+      def cleanup
+        if !@excel.visible
+          while @excel.ActiveWorkbook
+            @excel.ActiveWorkbook.Close(0)
+          end
+          @excel.Quit
+        end  
+      end
+      
+      def visible=(x)
+        @excel['Visible'] = x
+        @visible = x
+      end
+    end
+   
+    # Bookmarks are ways to continue the spreadsheet from a given point. 
+    # You can start from a specific tab and/or row/col in the spreadsheet.
+    # Additionally you can specify the number of pages and/or records to process
+    # so a user can start from SheetA and process 2 Sheets in the spreadsheet. 
+    #
+    # Bookmarks are formatted as follows:
+    #
+    # PageName[Col|Row]
+    #
+    # where the Col/Row is an optional parameter. This gives the 
+    # following bookmarks as possible continuation points:
+    #
+    # SheetA              start from this sheet
+    # SheetA[10]          this sheet is style :row, so start from row 10
+    # SheetA[F]           this sheet is style :col, so start from column F
+    # true                use the bookmark stored in .bookmarks
+    #
+    # The pagecount allows the user to start at the desired bookmark
+    # but only run through 1 or more sheets in the workbook
+    class Bookmark    
+      @foundpage   = false
+      @foundrecord = false
+      attr_accessor :page, :record
+      
+      def initialize(bookmark)
+        # Parse the bookmark into it's parts so we can 
+        # check for it as we read in the Sheet Records and Cells
+        @page, @record = parse_bookmark(bookmark)
+        raise ArgumentError, "Invalid record '#{@record}' - argument must be a row or column name" if @record && @record !~ /^([A-Z]+|\d+)$/i
+      end
+      
+      # Check to see if the current record or page matches the bookmark.
+      # For example, found?(:sheet, [pagename]) or found?(:record, [row/col])
+      # where pagename is the name of the worksheet and row/col could be the
+      # row or column depending on the style of the page (eg: 'A' or 6)
+      def found?(how, what)
+        case how
+        when :sheet
+          if @foundpage
+            # Trap the case when a record is specified 
+            # for a page and it does not exist
+            if !@foundrecord && what != @page 
+              raise Spreadsheet::BookmarkNotFound, "Record #{@record} does not exist on page #{@page}"
+            end
+            
+            true
+          else
+            if what == @page
+              @foundpage = true
+              # Set the foundrecord true so that it always 
+              # passes the comparison if the record is not set
+              @foundrecord = true if !@record
+              true
+            else
+              false
+            end
+          end
+        when :record
+          raise Spreadsheet::BookmarkNotFound, 'Should never get here: page should have been found first' if !@foundpage
+          if @foundrecord
+            true
+          else
+            if what == @record
+              @foundrecord = true
+              true
+            else
+              # TODO: RAISE if wrong type. (row is specified but it's a col)
+              false
+            end
+          end
+        else
+          raise ArgumentError, "Don't know how to check bookmark for '#{how}'"
+        end
+      end
+      
+      ##
+      # Returns true when either bookmark is not found or when pagecount has been reached. 
+      def do_not_execute?(how, what)
+        !found?(how, what)
+      end
+      
+    private 
+      
+      def parse_bookmark(name)
+        name =~ /([^\[]+)(\[(\S+)\])?/
+        pagename = $1
+        recordid = $3.upcase if $3
+        return pagename, recordid
+      end
+      
+    end
+    
+    
+    # This object is a container for the Excel workbook and 
+    # any options passed into the library. 
+    # 
+    # The book object can be parsed to find Records which in turn
+    # can be parsed to locate Cells. 
+    class Book
+      require 'win32ole'
+      attr_reader :filename
+      attr_accessor :bookmark
+
+      def initialize(filename)
+        @excel = Excel.instance
+        @filename = filename
+        raise ArgumentError, 'XLS file required for Book.new()' if !@filename
+        raise IOError, "Unable to find file: '#{@filename}'" if ! File.file?(@filename)
+        
+        # Create a bookmark
+        @bookmark = Bookmark.new(@excel.continue)
+  
+        # Open the workbook and get the ole reference to the workbook object
+        @o = @excel.open(@filename)
+      end  
+      
+      def [](name)
+        worksheet = @o.Worksheets(name)
+        if valid_worksheet(worksheet)
+          Sheet.new(self, worksheet)
+        else
+          raise SheetNotFound, name
+        end
+      end
+      
+      def each
+        @o.Worksheets.each do |worksheet| 
+          next if !valid_worksheet(worksheet)
+          Excel.instance.currentpage += 1
+          return if (@excel.pagecount > 0 && @excel.currentpage > @excel.pagecount)
+          return if (@excel.recordcount > 0 && @excel.currentrecord > @excel.recordcount)
+          yield Sheet.new(self, worksheet)
+        end
+      end
+      
+      def valid_worksheet(worksheet)
+        return false if worksheet.Visible == 0                                      # Skip hidden worksheets
+        return false if worksheet.name =~ /^#/                                      # Skip commented sheets
+        return false if worksheet.Tab.ColorIndex != ExcelConst::XlColorIndexNone    # Skip worksheets with colored tabs 
+        return false if (@excel.continue && @bookmark.do_not_execute?(:sheet, worksheet.name))
+        return true
+      end
+      
+      def ole_object 
+        @o
+      end
+      
+      def save
+        @o.Save if @excel
+     end
+     
+     def close
+        @o.Close(0) if @excel
+     end
+   end
+      
+    # Sheets store the information about records on the sheet. 
+    # In order to allow the user to add comments and have flexibility
+    # with how the data is laid out we have the following requirements:
+    #
+    # * The data will start at the first non-bold cell closest to Cell 'A1'
+    # * Bold cells will be ignored until we hit the first data cell. 
+    # * The header row (this is usually the attribute you're going to set) needs
+    #   to be bolded. We will use which side of the data (top or left) to determine
+    #   if the data is laid out in rows or in columns. 
+    # 
+    # Iterating over the Sheet will return Records which represent the row/column
+    #
+    
+    class Sheet
+      attr_reader :style, :name, :headers, :book,
+                  :firstrow, :firstcol, :lastrow, :lastcol
+  
+      class ObjectError < RuntimeError; end
+                          
+      def initialize(book, worksheet)
+        # TODO: Add check for duplicates if option set
+        @book     = book
+        @o        = worksheet
+        @name     = worksheet.name
+        self.select
+        # Order here is important because in these functions we
+        # will use the class variables from the prior call
+        (@lastrow, @lastcol)   = locate_last_data_cell
+        (@firstrow, @firstcol) = locate_first_data_cell
+        (@headers, @style)     = locate_headers 
+      end
+      
+      def to_s
+        "firstrow = #{@firstrow}\n" +
+        "firstcol = #{@firstcol}\n" +
+        "lastrow  = #{@lastrow}\n"  +
+        "lastcol  = #{@lastcol}\n"  +
+        "style    = #{@style}\n"
+      end
+      
+      def select
+        begin
+          @o.Select
+        rescue WIN32OLERuntimeError
+          raise ObjectError, "Unable to locate worksheet #{@name}"
+        end
+      end
+      
+      def select_home_cell
+        self.select
+        begin
+          @o.Cells(1,1).Select
+        rescue WIN32OLERuntimeError
+          raise ObjectError, "Unable to select cell in #{@name}"
+        end
+      end
+      
+      # A cell is a data cell if the cell's font is not bold
+      # and there is no background color
+      def datacell?(row,col)
+        @o.Cells(row,col).Font.Bold == false && @o.Cells(row,col).Interior.ColorIndex == ExcelConst::XlColorIndexNone
+      end
+      
+      # Get the ole range object for a row or column      
+      def cellrange(index, style=@style)
+        case style
+        when :row
+          @o.Range("#{colname(@firstcol)}#{index}:#{colname(@lastcol)}#{index}")
+        when :col
+          @o.Range("#{colname(index)}#{@firstrow}:#{colname(index)}#{@lastrow}")
+        end
+      end
+      
+      # Get an array of the values of cells in the range describing the row or column      
+      def cellrangevals(index, style=@style)
+        range = cellrange(index, style)
+        # It looks like range['Value'] returns an array with multiple
+        # items and a string with one item so coerce the string into 
+        # a one-dimensional array
+        return [range['Value']] if range['Value'].class != Array
+        case style
+        when :row
+          range['Value'][0] 
+        when :col
+          range['Value'].map{ |v| v[0] }
+        end
+      end
+      
+      # Translate a numerical column index to the alpha worksheet column the user sees
+      def colname(col)
+        @o.Columns(col).address.slice!(/(\w+)/)
+      end
+      
+      def each
+        case @style
+        when :row
+          firstrecord = @firstrow
+          lastrecord  = @lastrow
+        when :col
+          firstrecord = @firstcol
+          lastrecord  = @lastcol
+        end
+        (firstrecord..lastrecord).each do |record_index|
+          case @style
+          when :row
+            recordid = record_index.to_s
+          when :col
+            recordid = colname(record_index)
+          end    
+          excel = Excel.instance
+          next if excel.continue && !@book.bookmark.found?(:record, recordid)
+          excel.currentrecord += 1
+          return if (excel.recordcount > 0 && excel.currentrecord > excel.recordcount)
+          yield Record.new(self, record_index)
+        end
+      end
+      
+      def ole_object
+        @o
+      end
+      
+      def cell (record_index, cell_index)
+        Cell.new(self, record_index, cell_index)
+      end
+      
+      def [](index)
+        Record.new(self, index)
+      end
+      
+      def dump
+        vals = []
+        self.each { |record| vals << record.dump }
+        return vals
+      end
+      
+    
+    private
+      
+      ##
+      # Returns the fist row and column with data in the worksheet. If no data
+      # is found before the last row and column, these same values are returned. 
+      def locate_first_data_cell
+       (1..@lastrow).each do |row|
+         (1..@lastcol).each do |col|
+            if datacell?(row,col)
+              return row, col
+            end
+          end
+        end
+        return @lastrow, @lastcol
+      end
+      
+      ##
+      # Returns the last row and column with data in the worksheet. If no
+      # data is found (i.e., the sheet is empty) 1, 1 is returned.
+      def locate_last_data_cell
+        lastrow = @o.Cells.Find('What'            => '*',
+                                'SearchDirection' => ExcelConst::XlPrevious,
+                                'SearchOrder'     => ExcelConst::XlByRows)
+        lastcol = @o.Cells.Find('What'            => '*',
+                                'SearchDirection' => ExcelConst::XlPrevious,
+                                'SearchOrder'     => ExcelConst::XlByColumns)
+        if lastcol then col  = lastcol.Column else col = 0 end
+        if lastrow then row  = lastrow.Row    else row = 0 end
+        return row, col
+      end
+      
+      def locate_headers
+        # handle empty spreadsheet
+        return [nil, nil] if @firstrow + @lastrow + @firstcol + @lastcol == 0
+        headerrow = @firstrow - 1
+        if headerrow == 0 
+          testcell = @o.Cells(1,@firstcol)
+        else
+          testcell = @o.Cells(headerrow,@firstcol)
+        end
+        if headerrow > 0 && testcell.Font.Bold && testcell.Value.to_s.strip != ''
+          style = :row
+          headers  = cellrangevals(@firstrow-1, :row)
+        else
+          style = :col
+          headers  = cellrangevals(@firstcol-1, :col)
+        end
+        headers.map!{|x| x.strip if x}
+        return headers, style
+      end
+    end
+  
+    # Records store the information of a particular row/col of 
+    # a worksheet and allow iterating through the Record's Cells
+    class Record
+      attr_reader :recordindex, :sheet, :book
+      def initialize(sheet, index)
+        @sheet       = sheet
+        @book        = sheet.book
+        @recordindex = index
+        @range = @sheet.cellrange(@recordindex)
+      end
+      def each
+        @sheet.headers.each_index do |cell_index| # should be a value for each header
+          cell = @sheet.cell(@recordindex,cell_index + 1)
+          next if cell.nil? # Make sure the header exists
+          # Skip empty cells and italicized cells 
+          next if (cell.value == '' || cell.italic)
+          yield cell 
+        end
+      end
+      def select
+        @range.Select
+      end
+      def color=(c)
+        @range.Interior.ColorIndex = c
+      end
+      def [](index)
+        Cell.new(@sheet, @recordindex, index)
+      end
+      def to_s
+        @sheet.style.to_s + ':' + @recordindex.to_s
+      end
+      def dump
+        vals = []
+        self.each { |cell| vals << cell.value }
+        return vals
+      end
+    end
+    
+    # Cells store information on a specific worksheet cell. 
+    # The name is the Excel name for the cell (ie: A1, B2, etc), 
+    # the value is the value of the cell and the header is the 
+    # header for that row/column (usually the attribute/function parameter
+    # we're trying to set)
+    class Cell
+      ARRAY  = /\A\s*\[.+\]\s*\Z/ms
+      HASH   = /\A\s*\{.+\}\s*\Z/ms
+      BOOL   = /\A\s*(true|false)\s*\Z/i
+      NUMBER = /\A\s*-?\d+\.??\d*?\s*\Z/
+      REGEXP = /\A\s*(\/.+\/)\s*\Z/ms
+      attr_reader :name, :value, :recordid, :recordindex,
+                  :sheet, :book
+  
+      def initialize(sheet, record_index, cell_index)
+        @sheet       = sheet
+        @book        = sheet.book
+        @o           = sheet.ole_object
+        @cellindex   = cell_index
+        @recordindex = record_index
+        case @sheet.style
+        when :row
+          @row = @recordindex 
+          @col = @cellindex + @sheet.firstcol - 1 # taking into account the start of the used data range
+          @cell = @o.Cells(@row,@col)
+          @cell.NumberFormat == "@" ? @value = @cell.Value : @value = @cell.Text
+        when :col
+          @row = @cellindex + @sheet.firstrow - 1 # taking into account the start of the used data range
+          @col = @recordindex 
+          @cell = @o.Cells(@row,@col)
+          @cell.NumberFormat == "@" ? @value = @cell.Value : @value = @cell.Text
+        end
+        # Ignore blank values. There's not much use for cells 
+        # that are not set so skip them and normalize the return 
+        # to nil so we know that's the case
+        @value = @value.to_s.strip
+        if @value =~ NUMBER
+          @value = eval(@value) unless @value =~ /^0\d/ 
+        elsif @value =~ ARRAY || @value =~ HASH || @value =~ BOOL || @value =~ REGEXP 
+          @value = @value.downcase if @value =~ BOOL  # make sure it's not confused with a constant
+          @value = eval(@value)
+        end        
+        
+        # Put together the cell's name
+        column_letter = @sheet.colname(@col)
+        @name = column_letter + @row.to_s
+        
+        # The recordid is the row/col for the record
+        case @sheet.style
+        when :row
+          @recordid = @row.to_s
+        when :col
+          @recordid = column_letter
+        end
+      end
+      def header
+        # Return the header but strip off a trailing () if
+        # the user added for clarification purposes
+        @sheet.headers[@cellindex-1].gsub(/\(\)$/,'') if @sheet.headers[@cellindex-1]
+      end
+      def color=(c)
+        @cell.Interior.ColorIndex = c
+      end
+      def color
+        @cell.Interior.ColorIndex
+      end
+      def italic
+        @cell.Font.Italic
+      end
+      def comment=(c)
+        if c && !@cell.Comment
+          @cell.AddComment(c) 
+          @cell.Comment.Shape.TextFrame.AutoSize = true
+          @cell.Comment.Shape.TextFrame.Characters.Font.Size=8
+        end
+      end
+      def selectrecord
+        range = @sheet.cellrange(@recordindex)
+        range.Select
+      end
+      def value=(v)
+        @cell.Value = v
+      end
+      def ole_object 
+        @cell
+      end
+    end
+    
+  end # module
+end # module

data/lib/rasta/version.rb

@@ -0,0 +1,9 @@
+module Rasta
+  module VERSION
+     STRING = '0.1.8'
+     FULL_VERSION = "#{STRING}" #may add subversions here later
+     NAME   = "rasta"
+     URL    = "http://rasta.rubyforge.org/"  
+     DESCRIPTION = "#{NAME}-#{FULL_VERSION}: Ruby Spreadsheet Test Automation\n#{URL}"
+ end
+end