robust_excel_ole 1.31 → 1.32

data/lib/robust_excel_ole/list_row.rb

@@ -4,23 +4,30 @@ module RobustExcelOle
 
   using StringRefinement
 
-  class ListRow    
+  class ListRow < VbaObjects
 
-    def initialize(row_number)
-      @ole_listrow = ole_table.ListRows.Item(row_number)
+    attr_reader :ole_tablerow
+
+    alias ole_object ole_tablerow
+
+    def initialize(rownumber_or_oletablerow)
+      @ole_tablerow = if !rownumber_or_oletablerow.respond_to?(:succ)
+        rownumber_or_oletablerow       
+      else
+        ole_table.ListRows.Item(rownumber_or_oletablerow)
+      end
     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
+      ole_cell = ole_table.Application.Intersect(
+        @ole_tablerow.Range, ole_table.ListColumns.Item(column_number_or_name).Range)
+      value = ole_cell.Value
+      value.respond_to?(:gsub) ? value.encode('utf-8') : value
+    rescue WIN32OLERuntimeError
+      raise TableRowError, "could not determine the value at column #{column_number_or_name}\n#{$!.message}"
     end
 
     # sets the value of the cell with given column name or number
@@ -29,49 +36,66 @@ module RobustExcelOle
     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_tablerow.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}"
+        raise TableRowError, "could not assign value #{value.inspect} to cell at column #{column_number_or_name}\n#{$!.message}"
       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"
+      value = @ole_tablerow.Range.Value
+      return value if value==[nil]
+      value = if !value.respond_to?(:pop)
+        [value]
+      elsif value.first.respond_to?(:pop)
+        value.first
       end
+      value.map{|v| v.respond_to?(:gsub) ? v.encode('utf-8') : v}
+    rescue WIN32OLERuntimeError
+      raise TableError, "could not read values\n#{$!.message}"
     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
+    def values= values
+      updated_values = self.values
+      updated_values[0,values.length] = values
+      @ole_tablerow.Range.Value = [updated_values]
+      values
+    rescue WIN32OLERuntimeError
+      raise TableError, "could not set values #{values.inspect}\n#{$!.message}"
+    end
+
+    # key-value pairs of the row
+    # @return [Hash] key-value pairs of the row
+    def keys_values
+      ole_table.column_names.zip(values).to_h
     end
 
+    alias set_values values=
+    alias to_a values
+    alias to_h keys_values
+
     # 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        
+      @ole_tablerow.Range.Value = [[].fill(nil,0..(ole_table.ListColumns.Count)-1)]
+      nil
+    rescue WIN32OLERuntimeError
+      raise TableError, "could not delete values\n#{$!.message}"
+    end
+
+    def == other_listrow
+      other_listrow.is_a?(ListRow) && other_listrow.values == self.values
+    end
 
     def method_missing(name, *args)
+      # this should not happen:
+      raise(TableRowError, "internal error: ole_table not defined") unless self.class.method_defined?(:ole_table)
       name_str = name.to_s
-      core_name = name_str[-1]!='=' ? name_str : name_str[0..-2]
+      core_name = name_str.chomp('=')
       column_names = ole_table.HeaderRowRange.Value.first
       column_name = column_names.find do |c|
         c == core_name ||
@@ -82,9 +106,7 @@ module RobustExcelOle
         c.replace_umlauts.underscore.gsub(/\W/,'_') == core_name 
       end         
       if column_name
-        appended_eq = (name_str[-1]!='=' ? "" : "=")
-        method_name = core_name.replace_umlauts.underscore + appended_eq 
-        define_and_call_method(column_name,method_name,*args)
+        define_and_call_method(column_name, name, *args)
       else
         super(name, *args)
       end
@@ -97,14 +119,15 @@ module RobustExcelOle
 
     # @private
     def inspect    
-      "#<ListRow: " + "index:#{@ole_listrow.Index}" + " size:#{ole_table.ListColumns.Count}" + " #{ole_table.Name}" + ">"
+      "#<ListRow: index:#{@ole_tablerow.Index} size:#{ole_table.ListColumns.Count} #{ole_table.Name}>"
     end
 
   private
 
     def define_and_call_method(column_name,method_name,*args)
+      column_name = column_name.force_encoding('cp850')
       ole_cell = ole_table.Application.Intersect(
-          @ole_listrow.Range, ole_table.ListColumns.Item(column_name).Range)
+          @ole_tablerow.Range, ole_table.ListColumns.Item(column_name).Range)
       define_getting_setting_method(ole_cell,method_name)            
       self.send(method_name, *args)
     end
@@ -122,6 +145,10 @@ module RobustExcelOle
     end
 
   end
+
+  # @private
+  class TableRowError < WorksheetREOError
+  end
   
   TableRow = ListRow
 

data/lib/robust_excel_ole/range.rb

@@ -20,7 +20,7 @@ module RobustExcelOle
 
     def initialize(win32_range, worksheet = nil)
       @ole_range = win32_range
-      @worksheet = worksheet ? worksheet.to_reo : worksheet_class.new(self.Parent)
+      @worksheet = (worksheet ? worksheet : self.Parent).to_reo
     end
 
     def rows
@@ -32,8 +32,12 @@ module RobustExcelOle
     end
 
     def each
-      @ole_range.each_with_index do |ole_cell, index|
-        yield cell(index){ole_cell}
+      if block_given?
+        @ole_range.lazy.each_with_index do |ole_cell, index|
+          yield cell(index){ole_cell}
+        end
+      else
+        to_enum(:each).lazy
       end
     end
 
@@ -71,68 +75,90 @@ module RobustExcelOle
       end
     end
 
-    # returns flat array of the values of a given range
+    # returns values of a given range
     # @returns [Array] values of the range (as a nested array)    
+=begin  
     def value
-      begin
-        if !::RANGES_JRUBY_BUG
-          self.Value
-        else
-          values = []
-          rows.each do |r|
-            values_col = []
-            columns.each{ |c| values_col << worksheet.Cells(r,c).Value}
-            values << values_col
+      value = begin
+        if !::RANGES_JRUBY_BUG    
+          ole_range.Value[0,[ole_range.Rows.Count,worksheet.last_row].min].inject([]) do |res, row| 
+            res << (!row.nil? ? row[0,[ole_range.Columns.Count,worksheet.last_column].min] : nil)
           end
-          values
+        else
+          # optimization is possible here
+          rows_used_range = [rows, last_row].min
+          columns_used_rage = [columns, last_column].min
+          values = rows_used_range.map{|r| columns_used_range.map {|c| worksheet.Cells(r,c).Value} }
+          (values.size==1 && values.first.size==1) ? values.first.first : values
         end
-      rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
-        raise RangeNotEvaluatable, 'cannot read value'
-      end 
+      rescue
+        raise RangeNotEvaluatable, "cannot evaluate range #{self.inspect}\n#{$!.message}"
+      end
+      if value == -2146828288 + RobustExcelOle::XlErrName
+        raise RangeNotEvaluatable, "cannot evaluate range #{self.inspect}"
+      end
+      value
+    end
+=end
 
+    def value
+      value = begin
+        if !::RANGES_JRUBY_BUG    
+          ole_range.Application.Intersect(ole_range, worksheet.Range(
+            worksheet.Cells(1,1),worksheet.Cells(worksheet.last_row,worksheet.last_column))).Value
+        else
+          # optimization is possible here
+          rows_used_range = [rows, last_row].min
+          columns_used_rage = [columns, last_column].min
+          values = rows_used_range.map{|r| columns_used_range.map {|c| worksheet.Cells(r,c).Value} }
+          (values.size==1 && values.first.size==1) ? values.first.first : values
+        end
+      rescue
+        raise RangeNotEvaluatable, "cannot evaluate range #{self.inspect}\n#{$!.message}"
+      end
+      if value == -2146828288 + RobustExcelOle::XlErrName
+        raise RangeNotEvaluatable, "cannot evaluate range #{self.inspect}"
+      end
+      value
     end
 
     # sets the values if the range
     # @param [Variant] value
     def value=(value)
-      begin
-        if !::RANGES_JRUBY_BUG
-          ole_range.Value = value
-        else
-          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
+      if !::RANGES_JRUBY_BUG
+        ole_range.Value = value
+      else
+        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?(:pop) ? value[i][j] : value)
           end
         end
-        value
-      rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg  
-        raise RangeNotEvaluatable, "cannot assign value to range #{self.inspect}"
       end
+      value
+    rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg  
+      raise RangeNotEvaluatable, "cannot assign value to range #{self.inspect}\n#{$!.message}"
     end
 
-    alias_method :v, :value
-    alias_method :v=, :value=
+    alias v value
+    alias v= value=
 
     # sets the values if the range with a given color
     # @param [Variant] value
     # @option opts [Symbol] :color the color of the cell when set
     def set_value(value, opts = { })
-      begin
-        if !::RANGES_JRUBY_BUG
-          ole_range.Value = value
-        else
-          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
+      if !::RANGES_JRUBY_BUG
+        ole_range.Value = value
+      else
+        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?(:pop) ? value[i][j] : value)
           end
         end
-        ole_range.Interior.ColorIndex = opts[:color] unless opts[:color].nil?
-        value
-      rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg  
-        raise RangeNotEvaluatable, "cannot assign value to range #{self.inspect}"
       end
+      ole_range.Interior.ColorIndex = opts[:color] unless opts[:color].nil?
+      value
+    rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg  
+      raise RangeNotEvaluatable, "cannot assign value to range #{self.inspect}\n#{$!.message}"
     end
 
     # copies a range
@@ -144,52 +170,61 @@ module RobustExcelOle
       options = { }
       remaining_args.each do |arg|
         case arg
-        when Object::Range, Integer then dest_address = [dest_address,arg]
+        when ::Range, Integer then dest_address = [dest_address,arg]
         when Worksheet, WIN32OLE    then dest_sheet = arg.to_reo
         when Hash                   then options = arg
         else raise RangeNotCopied, "cannot copy range: argument error: #{remaining_args.inspect}"
         end
       end
-      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]
+      dest_range_address = destination_range(dest_address, dest_sheet, options)
+      dest_range = dest_sheet.range(dest_range_address)
+      if options[:values_only]
+        dest_range.v = !options[:transpose] ? self.v : self.v.transpose
+      else
+        copy_ranges(dest_address, dest_range, dest_range_address, dest_sheet, options)
+      end
+      dest_range
+    rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
+      raise RangeNotCopied, "cannot copy range\n#{$!.message}"
+    end
+
+  private
+
+    def destination_range(dest_address, dest_sheet, options)
+      rows, columns = address_tool.as_integer_ranges(dest_address)
+      dest_address_is_position = (rows.min == rows.max && columns.min == columns.max)
+      if !dest_address_is_position
+        [rows.min..rows.max,columns.min..columns.max]
+      else
+        ole_rows, ole_columns = self.Rows, self.Columns
+        [rows.min..rows.min + (options[:transpose] ? ole_columns : ole_rows).Count - 1, 
+         columns.min..columns.min + (options[:transpose] ? ole_rows : ole_columns).Count - 1]
+      end
+    end
+
+    def copy_ranges(dest_address, dest_range, dest_range_address, dest_sheet, options)
+      workbook = @worksheet.workbook
+      if dest_range.worksheet.workbook.excel == workbook.excel 
+        if options[:transpose]
+          self.Copy              
+          dest_range.PasteSpecial(XlPasteAll,XlPasteSpecialOperationNone,false,true)
         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.v = options[:transpose] ? self.v.transpose : self.v
+          self.Copy(dest_range.ole_range)
+        end            
+      else
+        if options[:transpose]
+          added_sheet = workbook.add_sheet
+          copy(dest_address, added_sheet, transpose: true)
+          added_sheet.range(dest_range_address).copy(dest_address,dest_sheet)
+          workbook.excel.with_displayalerts(false) {added_sheet.Delete}
         else
-          if dest_range.worksheet.workbook.excel == @worksheet.workbook.excel 
-            if options[:transpose]
-              self.Copy              
-              dest_range.PasteSpecial(XlPasteAll,XlPasteSpecialOperationNone,false,true)
-            else
-              self.Copy(dest_range.ole_range)
-            end            
-          else
-            if options[:transpose]
-              added_sheet = @worksheet.workbook.add_sheet
-              self.copy(dest_address, added_sheet, :transpose => true)
-              added_sheet.range(dest_range_address).copy(dest_address,dest_sheet)
-              @worksheet.workbook.excel.with_displayalerts(false) {added_sheet.Delete}
-            else
-              self.Copy
-              dest_sheet.Paste(dest_range.ole_range)
-            end
-          end
+          self.Copy
+          dest_sheet.Paste(dest_range.ole_range)
         end
-        dest_range
-      rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
-        raise RangeNotCopied, 'cannot copy range'
       end
     end
+     
+  public
 
     def == other_range
       other_range.is_a?(Range) &&
@@ -214,7 +249,7 @@ module RobustExcelOle
 
     # @private
     def to_s
-      "#<REO::Range: " + "#{@ole_range.Address('External' => true).gsub(/\$/,'')} " + ">"
+      "#<REO::Range: #{@ole_range.Address(External: true).gsub(/\$/,'')} >"
     end
 
     # @private
@@ -245,22 +280,19 @@ module RobustExcelOle
   private
 
     def method_missing(name, *args) 
-      if name.to_s[0,1] =~ /[A-Z]/
-        if ::ERRORMESSAGE_JRUBY_BUG
-          begin
-            @ole_range.send(name, *args)
-          rescue Java::OrgRacobCom::ComFailException 
-            raise VBAMethodMissingError, "unknown VBA property or method #{name.inspect}"
-          end
-        else
-          begin
-            @ole_range.send(name, *args)
-          rescue NoMethodError 
-            raise VBAMethodMissingError, "unknown VBA property or method #{name.inspect}"
-          end
+      super unless name.to_s[0,1] =~ /[A-Z]/
+      if ::ERRORMESSAGE_JRUBY_BUG
+        begin
+          @ole_range.send(name, *args)
+        rescue Java::OrgRacobCom::ComFailException 
+          raise VBAMethodMissingError, "unknown VBA property or method #{name.inspect}"
         end
       else
-        super
+        begin
+          @ole_range.send(name, *args)
+        rescue NoMethodError 
+          raise VBAMethodMissingError, "unknown VBA property or method #{name.inspect}"
+        end
       end
     end
   end