robust_excel_ole 1.27 → 1.32

data/lib/robust_excel_ole/list_object.rb

@@ -1,10 +1,9 @@
 # -*- coding: utf-8 -*-
-
 module RobustExcelOle
 
-  class ListRow
-  end
-
+  using ToReoRefinement
+  using FindAllIndicesRefinement
+ 
   # This class essentially wraps a Win32Ole ListObject. 
   # You can apply all VBA methods (starting with a capital letter) 
   # that you would apply for a ListObject. 
@@ -12,6 +11,8 @@ module RobustExcelOle
 
   class ListObject < VbaObjects
 
+    include Enumerable
+
     attr_reader :ole_table
 
     alias ole_object ole_table
@@ -55,146 +56,137 @@ module RobustExcelOle
           @ole_table.Name = table_name_or_number
           @ole_table.HeaderRowRange.Value = [column_names] unless column_names.empty?
         rescue WIN32OLERuntimeError => msg # , Java::OrgRacobCom::ComFailException => msg
-          raise TableError, "error #{$!.message}"
+          raise TableError, "#{$!.message}"
         end
       end
 
-
       ole_table = @ole_table
+
       @row_class = Class.new(ListRow) do
 
         @@ole_table = ole_table
 
-        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
+        def ole_table
+          @@ole_table
         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
+    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
+    # @return [Enumerator] traversing all list row objects
+    def each
+      if block_given?
+        @ole_table.ListRows.lazy.each do |ole_listrow|
+          yield @row_class.new(ole_listrow)
         end
+      else
+        to_enum(:each).lazy
+      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
+    # accesses a table row object
+    # @param [Variant]  a hash of key (key column: value) or a row number (>= 1) 
+    # @option opts [Variant] limit: maximal number of matching table rows to return, or return the first matching table row (default :first)
+    # @return [Variant] a listrow, if limit == :first
+    #                   an array of listrows, with maximal number=limit, if list rows were found and limit is not :first
+    #                   nil, if no list object was found
+    def [] (key_hash_or_number, options = { })
+      return @row_class.new(key_hash_or_number) if key_hash_or_number.respond_to?(:succ)
+      options = {limit: :first}.merge(options)   
+      opts = options.dup
+      opts[:limit] = 1 if options[:limit] == :first
+      key_hash = key_hash_or_number.transform_keys{|k| k.downcase.to_sym}
+      matching = if @ole_table.ListRows.Count < 150
+        matching_via_traversing(key_hash, opts)
+      else
+        matching_via_filter(key_hash, opts)
+      end
+      matching_listrows = matching.map{ |r| @row_class.new(r) }
+      options[:limit] == :first ? matching_listrows.first : matching_listrows
+    end
 
-        def method_missing(name, *args)
-          name_str = name.to_s
-          core_name = name_str[-1]!='=' ? name_str : name_str[0..-2]
-          column_names = @@ole_table.HeaderRowRange.Value.first
-          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
-            method_name = core_name.gsub(/\W/,'') + (name_str[-1]!='=' ? "" : "=")
-            define_and_call_method(column_name,method_name,*args)
-          else
-            super(name, *args)
-          end
-        end
+  private
 
-      private
+   def matching_via_traversing(key_hash, opts)      
+      encode_utf8 = ->(val) {val.respond_to?(:gsub) ? val.encode('utf-8') : val}
+      cn2i = column_names_to_index
+      max_matching_num = opts[:limit] || 65536     
+      matching_rows = @ole_table.ListRows.lazy.select { |listrow|
+        rowvalues = listrow.Range.Value.first
+        key_hash.all?{ |key,val| encode_utf8.(rowvalues[cn2i[key]])==val}
+      }.take(max_matching_num).to_a
+    rescue
+      raise(TableError, "cannot find row with key #{key_hash}")
+    end
 
-        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) do |value|
-              ole_cell.Value = value
+    def matching_via_filter(key_hash, opts)
+      ole_worksheet = self.Parent
+      ole_workbook =  ole_worksheet.Parent
+      row_numbers = []
+      ole_workbook.retain_saved do
+        added_ole_worksheet = ole_workbook.Worksheets.Add
+        criteria = Table.new(added_ole_worksheet, "criteria", [2,1], 2, key_hash.keys.map{|s| s.to_s})
+        criteria[1].values = key_hash.values
+        self.Range.AdvancedFilter({
+          Action: XlFilterInPlace, 
+          CriteriaRange: added_ole_worksheet.range([2..3,1..key_hash.length]).ole_range, Unique: false})
+        filtered_ole_range = self.DataBodyRange.SpecialCells(XlCellTypeVisible) rescue nil         
+        ole_worksheet.ShowAllData        
+        self.Range.AdvancedFilter({Action: XlFilterInPlace, 
+                                   CriteriaRange: added_ole_worksheet.range([1,1]).ole_range, Unique: false})          
+        ole_workbook.Parent.with_displayalerts(false){added_ole_worksheet.Delete}
+        if filtered_ole_range
+          filtered_ole_range.Areas.each do |area|
+            break if area.Rows.each do |row|
+              row_numbers << row.Row-position.first
+              break true if row_numbers.count == opts[:limit]
             end
           end
-        end
-      end
+        end          
+        @ole_table = ole_worksheet.table(self.Name)
+      end   
+      row_numbers
+    rescue
+      raise(TableError, "cannot find row with key #{key_hash}")
+    end
 
-      # accesses a table row object
-      # @param [Integer]  a row number (>= 1)
-      # @return [ListRow] a object of dynamically constructed class with superclass ListRow 
-      def [] row_number
-        @row_class.new(row_number)
-      end
+  public    
 
+    # @return [Integer] number of rows
+    def rows_number
+      @ole_table.ListRows.Count
     end
 
+    # @return [Array] values of the table
+    def value
+      [column_names] + self.DataBodyRange.Value
+    end
+    
     # @return [Array] a list of column names
     def column_names
-      begin
-        @ole_table.HeaderRowRange.Value.first
-      rescue WIN32OLERuntimeError
-        raise TableError, "could not determine column names"
-      end
+      @ole_table.HeaderRowRange.Value.first.map{|v| v.encode('utf-8')}
+    rescue WIN32OLERuntimeError
+      raise TableError, "could not determine column names\n#{$!.message}"
     end
 
+    # @return [Hash] pairs of column names and index
+    def column_names_to_index
+      header_row_values = @ole_table.HeaderRowRange.Value.first
+      header_row_values.map{|v| v.encode('utf-8').downcase.to_sym}.zip(0..header_row_values.size-1).to_h
+    rescue WIN32OLERuntimeError
+      raise TableError, "could not determine column names\n#{$!.message}"
+    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
+      @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) + "\n#{$!.message}")
     end
 
     # adds a column    
@@ -202,116 +194,96 @@ module RobustExcelOle
     # @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
+      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) + "\n#{$!.message}")
     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
+    def delete_row(row_number)                          # :nodoc: #
+      @ole_table.ListRows.Item(row_number).Delete
+    rescue WIN32OLERuntimeError
+      raise TableError, "could not delete row #{row_number.inspect}\n#{$!.message}"
     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
+    def delete_column(column_number_or_name)              # :nodoc: #
+      @ole_table.ListColumns.Item(column_number_or_name).Delete
+    rescue WIN32OLERuntimeError
+      raise TableError, "could not delete column #{column_number_or_name.inspect}\n#{$!.message}"
     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
+      @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}\n#{$!.message}"
     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
+      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}\n#{$!.message}"
     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
+    def rename_column(name_or_number, new_name)              # :nodoc: #
+      @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}\n#{$!.message}"
     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
+      @ole_table.ListRows.Item(row_number).Range.Value.first.map{|v| v.respond_to?(:gsub) ? v.encode('utf-8') : v}
+    rescue WIN32OLERuntimeError
+      raise TableError, "could not read the values of row #{row_number.inspect}\n#{$!.message}"
     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
+      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}\n#{$!.message}"
     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
+      @ole_table.ListColumns.Item(column_number_or_name).Range.Value[1,@ole_table.ListRows.Count].flatten.map{|v| v.respond_to?(:gsub) ? v.encode('utf-8') : v}
+    rescue WIN32OLERuntimeError
+      raise TableError, "could not read the values of column #{column_number_or_name.inspect}\n#{$!.message}"
     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
+      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}\n#{$!.message}"
     end
 
     # deletes rows that have an empty contents
@@ -324,7 +296,7 @@ module RobustExcelOle
         if row.Range.Value == nil_array
           row.Delete
         else
-          i = i+1
+          i += 1
         end
       end
     end
@@ -339,7 +311,7 @@ module RobustExcelOle
         if column.Range.Value[1..-1] == nil_array
           column.Delete
         else
-          i = i+1
+          i += 1
         end
       end
     end
@@ -348,15 +320,14 @@ module RobustExcelOle
     # @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
+      encode_utf8 = ->(val) {val.respond_to?(:gsub) ? val.encode('utf-8') : val}   
+      listrows = @ole_table.ListRows   
+      listrows.map { |listrow|
+        listrow_range = listrow.Range
+        listrow_range.Value.first.map{ |v| encode_utf8.(v) }.find_all_indices(value).map do |col_number| 
+          listrow_range.Cells(1,col_number+1).to_reo 
         end
-      end
-      result
+      }.flatten
     end
 
     # sorts the rows of the list object according to the given column
@@ -370,6 +341,19 @@ module RobustExcelOle
       @ole_table.Sort.Apply
     end
 
+    # @return [Array] position of the first cell of the table
+    def position
+      first_cell = self.Range.Cells(1,1)
+      @position = [first_cell.Row, first_cell.Column]
+    end
+
+    def == other_table
+      other_table.is_a?(ListObject) && 
+      self.HeaderRowRange.Value == other_table.HeaderRowRange.Value &&
+      self.DataBodyRange.Value == other_table.DataBodyRange.Value
+    end
+
+
     # @private
     # returns true, if the list object responds to VBA methods, false otherwise
     def alive?
@@ -387,9 +371,9 @@ module RobustExcelOle
 
     # @private
     def inspect    
-      "#<ListObject:" + "#{@ole_table.Name}" + 
+      "#<ListObject:#{@ole_table.Name}" + 
       " #{@ole_table.ListRows.Count}x#{@ole_table.ListColumns.Count}" +
-      " #{@ole_table.Parent.Name}" + " #{@ole_table.Parent.Parent.Name}" + ">"
+      " #{@ole_table.Parent.Name} #{@ole_table.Parent.Parent.Name}>"
     end
 
     include MethodHelpers
@@ -397,22 +381,19 @@ module RobustExcelOle
   private
 
     def method_missing(name, *args) 
-      if name.to_s[0,1] =~ /[A-Z]/
-        if ::ERRORMESSAGE_JRUBY_BUG
-          begin
-            @ole_table.send(name, *args)
-          rescue Java::OrgRacobCom::ComFailException 
-            raise VBAMethodMissingError, "unknown VBA property or method #{name.inspect}"
-          end
-        else
-          begin
-            @ole_table.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_table.send(name, *args)
+        rescue Java::OrgRacobCom::ComFailException 
+          raise VBAMethodMissingError, "unknown VBA property or method #{name.inspect}"
         end
       else
-        super
+        begin
+          @ole_table.send(name, *args)
+        rescue NoMethodError 
+          raise VBAMethodMissingError, "unknown VBA property or method #{name.inspect}"
+        end
       end
     end
   end
@@ -421,11 +402,6 @@ module RobustExcelOle
   class TableError < WorksheetREOError
   end
 
-  # @private
-  class TableRowError < WorksheetREOError
-  end
-
   Table = ListObject
-  TableRow = ListRow
 
 end