robust_excel_ole 1.19.10 → 1.21

data/lib/robust_excel_ole/list_object.rb

@@ -14,6 +14,8 @@ module RobustExcelOle
 
     attr_reader :ole_table
 
+    alias ole_object ole_table
+
     # constructs a list object (or table).
     # @param [Variable] worksheet_or_ole_listobject  a worksheet or a Win32Ole list object
     # @param [Variable] table_name_or_number         a table name or table number
@@ -58,31 +60,99 @@ module RobustExcelOle
         def initialize(row_number)
           @ole_listrow = @@ole_table.ListRows.Item(row_number)
         end
-       
+
+        # returns the value of the cell with given column name or number
+        # @param [Variant]  column number or column name
+        # @return [Variant] value of the cell 
+        def [] column_number_or_name
+          begin
+            ole_cell = @@ole_table.Application.Intersect(
+              @ole_listrow.Range, @@ole_table.ListColumns.Item(column_number_or_name).Range)
+            ole_cell.Value
+          rescue WIN32OLERuntimeError
+            raise TableRowError, "could not determine the value at column #{column_number_or_name}"
+          end
+        end
+
+
+        def []=(column_number_or_name, value)
+          begin
+            ole_cell = @@ole_table.Application.Intersect(
+              @ole_listrow.Range, @@ole_table.ListColumns.Item(column_number_or_name).Range)
+            ole_cell.Value = value
+          rescue WIN32OLERuntimeError
+            raise TableRowError, "could not assign value #{value.inspect} to cell at column #{column_number_or_name}"
+          end
+        end
+
+        # values of the row
+        # @return [Array] values of the row
+        def values
+          begin
+            @ole_listrow.Range.Value.first
+          rescue WIN32OLERuntimeError
+            raise TableError, "could not read values"
+          end
+        end
+
+        # sets the values of the row
+        # @param [Array] values of the row
+        def set_values values
+          begin
+            updated_values = self.values
+            updated_values[0,values.length] = values
+            @ole_listrow.Range.Value = [updated_values]
+            values
+          rescue WIN32OLERuntimeError
+            raise TableError, "could not set values #{values.inspect}"
+          end
+        end
+
+        # deletes the values of the row
+        def delete_values
+          begin
+            @ole_listrow.Range.Value = [[].fill(nil,0..(@@ole_table.ListColumns.Count)-1)]
+            nil
+          rescue WIN32OLERuntimeError
+            raise TableError, "could not delete values"
+          end
+        end
+
         def method_missing(name, *args)
-          name_before_last_equal = name.to_s.split('=').first
+          name_str = name.to_s
+          core_name = name_str[-1]!='=' ? name_str : name_str[0..-2]
           column_names = @@ole_table.HeaderRowRange.Value.first
-          method_names = column_names.map{|c| c.underscore.gsub(/[^[\w\d]]/, '_')}
-          column_name = column_names[method_names.index(name_before_last_equal)]
+          column_name = column_names.find do |c|
+            c == core_name ||  
+            c.gsub(/\W/,'') == core_name ||
+            c.replace_umlauts == core_name ||
+            c.gsub(/\W/,'').replace_umlauts == core_name ||
+            c.gsub(/\W/,'').replace_umlauts.underscore.gsub(/[^[\w\d]]/, '_').delete_multiple_underscores == core_name           
+          end
           if column_name
-            ole_cell = @@ole_table.Application.Intersect(
-              @ole_listrow.Range, @@ole_table.ListColumns(column_name).Range)
-            define_getting_setting_method(ole_cell,name.to_s)            
-            self.send(name, *args)
+            method_name = core_name.gsub(/\W/,'') + (name_str[-1]!='=' ? "" : "=")
+            define_and_call_method(column_name,method_name,*args)
           else
-            super
+            super(name, *args)
           end
         end
 
       private
 
-        def define_getting_setting_method(ole_cell,name_str)
-          if name_str[-1] != '='
-            self.class.define_method(name_str) do
+        def define_and_call_method(column_name,method_name,*args)
+          ole_cell = @@ole_table.Application.Intersect(
+              @ole_listrow.Range, @@ole_table.ListColumns.Item(column_name).Range)
+          define_getting_setting_method(ole_cell,method_name)            
+          self.send(method_name, *args)
+        end
+       
+        def define_getting_setting_method(ole_cell,name)
+          if name[-1] != '='
+            self.class.define_method(name) do
               ole_cell.Value
             end
           else
-            self.class.define_method(name_str) do |value|
+            self.class.define_method(name) do |value|
               ole_cell.Value = value
             end
           end
@@ -98,8 +168,208 @@ module RobustExcelOle
 
     end
 
+    # @return [Array] a list of column names
     def column_names
-      @ole_table.HeaderRowRange.Value.first
+      begin
+        @ole_table.HeaderRowRange.Value.first
+      rescue WIN32OLERuntimeError
+        raise TableError, "could not determine column names"
+      end
+    end
+
+    # adds a row
+    # @param [Integer] position of the new row
+    # @param [Array]   values of the column
+    def add_row(position = nil, contents = nil)
+      begin
+        @ole_table.ListRows.Add(position)
+        set_row_values(position, contents) if contents
+      rescue WIN32OLERuntimeError
+        raise TableError, ("could not add row" + (" at position #{position.inspect}" if position))
+      end
+    end
+
+    # adds a column    
+    # @param [String]  name of the column
+    # @param [Integer] position of the new column
+    # @param [Array]   values of the column
+    def add_column(column_name = nil, position = nil, contents = nil)
+      begin
+        new_column = @ole_table.ListColumns.Add(position)
+        new_column.Name = column_name if column_name
+        set_column_values(column_name, contents) if contents
+      rescue WIN32OLERuntimeError, TableError
+        raise TableError, ("could not add column"+ ("at position #{position.inspect} with name #{column_name.inspect}" if position))
+      end
+    end
+
+    # deletes a row
+    # @param [Integer] position of the old row
+    def delete_row(row_number)
+      begin
+        @ole_table.ListRows.Item(row_number).Delete
+      rescue WIN32OLERuntimeError
+        raise TableError, "could not delete row #{row_number.inspect}"
+      end
+    end
+
+    # deletes a column
+    # @param [Variant] column number or column name
+    def delete_column(column_number_or_name)
+      begin
+        @ole_table.ListColumns.Item(column_number_or_name).Delete
+      rescue WIN32OLERuntimeError
+        raise TableError, "could not delete column #{column_number_or_name.inspect}"
+      end
+    end
+
+    # deletes the contents of a row
+    # @param [Integer] row number
+    def delete_row_values(row_number)
+      begin
+        @ole_table.ListRows.Item(row_number).Range.Value = [[].fill(nil,0..(@ole_table.ListColumns.Count-1))]
+        nil
+      rescue WIN32OLERuntimeError
+        raise TableError, "could not delete contents of row #{row_number.inspect}"
+      end
+    end
+
+    # deletes the contents of a column
+    # @param [Variant] column number or column name
+    def delete_column_values(column_number_or_name)
+      begin
+        column_name = @ole_table.ListColumns.Item(column_number_or_name).Range.Value.first
+        @ole_table.ListColumns.Item(column_number_or_name).Range.Value = [column_name] + [].fill([nil],0..(@ole_table.ListRows.Count-1))
+        nil
+      rescue WIN32OLERuntimeError
+        raise TableError, "could not delete contents of column #{column_number_or_name.inspect}"
+      end
+    end
+
+    # renames a row
+    # @param [String] previous name or number of the column
+    # @param [String] new name of the column   
+    def rename_column(name_or_number, new_name)
+      begin
+        @ole_table.ListColumns.Item(name_or_number).Name = new_name
+      rescue
+        raise TableError, "could not rename column #{name_or_number.inspect} to #{new_name.inspect}"
+      end
+    end
+
+    # contents of a row
+    # @param [Integer] row number
+    # @return [Array] contents of a row
+    def row_values(row_number)
+      begin
+        @ole_table.ListRows.Item(row_number).Range.Value.first
+      rescue WIN32OLERuntimeError
+        raise TableError, "could not read the values of row #{row_number.inspect}"
+      end
+    end
+
+    # sets the contents of a row
+    # @param [Integer] row number
+    # @param [Array]   values of the row
+    def set_row_values(row_number, values)
+      begin
+        updated_values = row_values(row_number)
+        updated_values[0,values.length] = values
+        @ole_table.ListRows.Item(row_number).Range.Value = [updated_values]
+        values
+      rescue WIN32OLERuntimeError
+        raise TableError, "could not set the values of row #{row_number.inspect}"
+      end
+    end
+
+    # @return [Array] contents of a column
+    def column_values(column_number_or_name)
+      begin
+        @ole_table.ListColumns.Item(column_number_or_name).Range.Value[1,@ole_table.ListRows.Count].flatten
+      rescue WIN32OLERuntimeError
+        raise TableError, "could not read the values of column #{column_number_or_name.inspect}"
+      end
+    end
+
+    # sets the contents of a column
+    # @param [Integer] column name or column number
+    # @param [Array]   contents of the column
+    def set_column_values(column_number_or_name, values)
+      begin
+        updated_values = column_values(column_number_or_name)
+        updated_values[0,values.length] = values
+        column_name = @ole_table.ListColumns.Item(column_number_or_name).Range.Value.first
+        @ole_table.ListColumns.Item(column_number_or_name).Range.Value = column_name + updated_values.map{|v| [v]}
+        values
+      rescue WIN32OLERuntimeError
+        raise TableError, "could not read the values of column #{column_number_or_name.inspect}"
+      end
+    end
+
+    # deletes rows that have an empty contents
+    def delete_empty_rows
+      listrows = @ole_table.ListRows
+      nil_array = [[].fill(nil,0..(@ole_table.ListColumns.Count-1))]
+      i = 1
+      while i <= listrows.Count do 
+        row = listrows.Item(i)
+        if row.Range.Value == nil_array
+          row.Delete
+        else
+          i = i+1
+        end
+      end
+    end
+
+    # deletes columns that have an empty contents
+    def delete_empty_columns
+      listcolumns = @ole_table.ListColumns
+      nil_array = [].fill([nil],0..(@ole_table.ListRows.Count-1))
+      i = 1
+      while i <= listcolumns.Count do 
+        column = listcolumns.Item(i)
+        if column.Range.Value[1..-1] == nil_array
+          column.Delete
+        else
+          i = i+1
+        end
+      end
+    end
+
+    # finds all cells containing a given value
+    # @param[Variant] value to find
+    # @return [Array] win32ole cells containing the given value
+    def find_cells(value)
+      listrows = @ole_table.ListRows      
+      result = []
+      (1..listrows.Count).each do |row_number|
+        row_values(row_number).find_each_index(value).each do |col_number|
+          result << @ole_table.Application.Intersect(listrows.Item(row_number).Range, 
+                                                     @ole_table.ListColumns.Item(col_number+1).Range).to_reo
+        end
+      end
+      result
+    end
+
+    # sorts the rows of the list object according to the given column
+    # @param [Variant] column number or name
+    # @option opts [Symbol]   sort order
+    def sort(column_number_or_name, sort_order = :ascending)
+      key_range = @ole_table.ListColumns.Item(column_number_or_name).Range
+      @ole_table.Sort.SortFields.Clear
+      sort_order_option = sort_order == :ascending ? XlAscending : XlDescending
+      @ole_table.Sort.SortFields.Add(key_range, XlSortOnValues,sort_order_option,XlSortNormal)
+      @ole_table.Sort.Apply
+    end
+
+    # @private
+    # returns true, if the list object responds to VBA methods, false otherwise
+    def alive?
+      @ole_table.ListRows
+      true
+    rescue
+      # trace $!.message
+      false
     end
 
     # @private
@@ -110,10 +380,12 @@ module RobustExcelOle
     # @private
     def inspect    
       "#<ListObject:" + "#{@ole_table.Name}" + 
-      " size:#{@ole_table.ListRows.Count}x#{@ole_table.ListColumns.Count}" +
-      " worksheet:#{@ole_table.Parent.Name}" + " workbook:#{@ole_table.Parent.Parent.Name}" + ">"
+      " #{@ole_table.ListRows.Count}x#{@ole_table.ListColumns.Count}" +
+      " #{@ole_table.Parent.Name}" + " #{@ole_table.Parent.Parent.Name}" + ">"
     end
 
+    include MethodHelpers
+
   private
 
     def method_missing(name, *args) 
@@ -141,6 +413,10 @@ module RobustExcelOle
   class TableError < WorksheetREOError
   end
 
+  # @private
+  class TableRowError < WorksheetREOError
+  end
+
   Table = ListObject
   TableRow = ListRow
 

data/lib/robust_excel_ole/range.rb

@@ -8,14 +8,20 @@ module RobustExcelOle
   # See https://docs.microsoft.com/en-us/office/vba/api/excel.worksheet#methods
 
   class Range < VbaObjects
+
     include Enumerable
+    
     attr_reader :ole_range
     attr_reader :worksheet
 
+    alias ole_object ole_range
+
+
     def initialize(win32_range, worksheet = nil)
       @ole_range = win32_range
-      @worksheet = worksheet ? worksheet : worksheet_class.new(self.Parent)
-      #@worksheet = worksheet_class.new(self.Parent)
+      @worksheet = worksheet ? worksheet.to_reo : worksheet_class.new(self.Parent)
+      address_r1c1 = @ole_range.AddressLocal(true,true,XlR1C1)
+      @rows, @columns = address_tool.as_integer_ranges(address_r1c1)
     end
 
     def each
@@ -64,12 +70,10 @@ module RobustExcelOle
         if !::RANGES_JRUBY_BUG
           self.Value
         else
-          address_r1c1 = self.AddressLocal(true,true,XlR1C1)
-          row, col = address_tool.as_integer_ranges(address_r1c1)
           values = []
-          row.each do |r|
+          @rows.each do |r|
             values_col = []
-            col.each{ |c| values_col << worksheet.Cells(r,c).Value}
+            @columns.each{ |c| values_col << worksheet.Cells(r,c).Value}
             values << values_col
           end
           values
@@ -85,10 +89,8 @@ module RobustExcelOle
         if !::RANGES_JRUBY_BUG
           ole_range.Value = value
         else
-          address_r1c1 = ole_range.AddressLocal(true,true,XlR1C1)
-          row, col = address_tool.as_integer_ranges(address_r1c1)
-          row.each_with_index do |r,i|
-            col.each_with_index do |c,j|
+          @rows.each_with_index do |r,i|
+            @columns.each_with_index do |c,j|
               ole_range.Cells(i+1,j+1).Value = (value.respond_to?(:first) ? value[i][j] : value)
             end
           end
@@ -107,55 +109,52 @@ module RobustExcelOle
     # @options [Worksheet] the destination worksheet
     # @options [Hash] options: :transpose, :values_only
     def copy(dest_address1, sheet_or_dest_address2 = :__not_provided, options_or_sheet = :__not_provided, not_provided_or_options = :__not_provided)
-      dest_address = if sheet_or_dest_address2.is_a?(Object::Range) or sheet_or_dest_address2.is_a?(Integer)
-        [dest_address1,sheet_or_dest_address2] 
-      else
-        dest_address1
-      end
-      dest_sheet = if sheet_or_dest_address2.is_a?(Worksheet)
-        sheet_or_dest_address2
-      else
-        if options_or_sheet.is_a?(Worksheet)
-          options_or_sheet
+      begin
+        dest_address = if sheet_or_dest_address2.is_a?(Object::Range) or sheet_or_dest_address2.is_a?(Integer)
+          [dest_address1,sheet_or_dest_address2] 
         else
-          @worksheet
+          dest_address1
         end
-      end
-      options = if options_or_sheet.is_a?(Hash)
-        options_or_sheet 
-      else
-        if not_provided_or_options.is_a?(Hash)
-          not_provided_or_options
+        dest_sheet = if sheet_or_dest_address2.is_a?(Worksheet) or sheet_or_dest_address2.is_a?(WIN32OLE)
+          sheet_or_dest_address2.to_reo
         else
-          { }
+          if options_or_sheet.is_a?(Worksheet) or options_or_sheet.is_a?(WIN32OLE)
+            options_or_sheet.to_reo
+          else
+            @worksheet
+          end
         end
-      end
-      rows, columns = address_tool.as_integer_ranges(dest_address)
-      dest_address_is_position = (rows.min == rows.max && columns.min == columns.max)
-      dest_range_address = if (not dest_address_is_position) 
-          [rows.min..rows.max,columns.min..columns.max]
+        options = if options_or_sheet.is_a?(Hash)
+          options_or_sheet 
         else
-          if (not options[:transpose])
-            [rows.min..rows.min+self.Rows.Count-1,
-             columns.min..columns.min+self.Columns.Count-1]
+          if not_provided_or_options.is_a?(Hash)
+            not_provided_or_options
           else
-            [rows.min..rows.min+self.Columns.Count-1,
-             columns.min..columns.min+self.Rows.Count-1]
+            { }
           end
         end
-      dest_range = dest_sheet.range(dest_range_address)
-      begin
+        rows, columns = address_tool.as_integer_ranges(dest_address)
+        dest_address_is_position = (rows.min == rows.max && columns.min == columns.max)
+        dest_range_address = if (not dest_address_is_position) 
+            [rows.min..rows.max,columns.min..columns.max]
+          else
+            if (not options[:transpose])
+              [rows.min..rows.min+self.Rows.Count-1,
+               columns.min..columns.min+self.Columns.Count-1]
+            else
+              [rows.min..rows.min+self.Columns.Count-1,
+               columns.min..columns.min+self.Rows.Count-1]
+            end
+          end
+        dest_range = dest_sheet.range(dest_range_address)
         if options[:values_only]
-          # dest_range.Value = options[:transpose] ? self.Value.transpose : self.Value
           dest_range.v = options[:transpose] ? self.v.transpose : self.v
         else
           if dest_range.worksheet.workbook.excel == @worksheet.workbook.excel 
             if options[:transpose]
               self.Copy              
-              #dest_range.PasteSpecial('transpose' => true) 
               dest_range.PasteSpecial(XlPasteAll,XlPasteSpecialOperationNone,false,true)
             else
-              #self.Copy('destination' => dest_range.ole_range)
               self.Copy(dest_range.ole_range)
             end            
           else
@@ -166,7 +165,6 @@ module RobustExcelOle
               @worksheet.workbook.excel.with_displayalerts(false) {added_sheet.Delete}
             else
               self.Copy
-              #dest_sheet.Paste('destination' => dest_range.ole_range)
               dest_sheet.Paste(dest_range.ole_range)
             end
           end
@@ -184,7 +182,7 @@ module RobustExcelOle
     def copy_special(dest_address, dest_sheet = :__not_provided, options = { })
       rows, columns = address_tool.as_integer_ranges(dest_address)
       dest_sheet = @worksheet if dest_sheet == :__not_provided
-      dest_address_is_position = (rows.min == rows.max && columns.min == columns.max)
+      dest_address_is_position = (rows.min == rows.max && @columns.min == @columns.max)
       dest_range_address = if (not dest_address_is_position) 
           [rows.min..rows.max,columns.min..columns.max]
         else
@@ -239,6 +237,26 @@ module RobustExcelOle
       @worksheet.workbook.excel
     end
 
+    # @private
+    # returns true, if the Range object responds to VBA methods, false otherwise
+    def alive?
+      @ole_range.Row
+      true
+    rescue
+      # trace $!.message
+      false
+    end
+
+    # @private
+    def to_s
+      "#<REO::Range: " + "[#{@rows},#{@columns}] " + "#{worksheet.Name} " + ">"
+    end
+
+    # @private
+    def inspect
+      self.to_s
+    end
+
     # @private
     def self.worksheet_class   
       @worksheet_class ||= begin
@@ -254,6 +272,8 @@ module RobustExcelOle
       self.class.worksheet_class
     end
 
+    include MethodHelpers
+
   private
 
     def method_missing(name, *args)