robust_excel_ole 1.31 → 1.32

data/lib/robust_excel_ole/general.rb

@@ -1,33 +1,54 @@
 # -*- coding: utf-8 -*-
 require 'pathname'
 
-# @private
-#class WIN32OLE
 module ToReoRefinement
 
   refine WIN32OLE do
 
     # type-lifting WIN32OLE objects to RobustExcelOle objects
     def to_reo
-      General.class2method.each do |element|
-        classname = element.first.first
-        method = element.first.last
-        begin
-          self.send(method)
-          if classname == RobustExcelOle::Range && self.Rows.Count == 1 && self.Columns.Count == 1
-            return Cell.new(self, self.Parent)
-          else
-            return classname.new(self)
+      General.main_classes_ole_types_and_recognising_methods.each do |classname, ole_type, methods|
+        if !::OLETYPE_JRUBY_BUG
+          if self.ole_type.name == ole_type
+            if classname != RobustExcelOle::Range
+              return classname.new(self)
+            elsif self.Rows.Count == 1 && self.Columns.Count == 1
+              return RobustExcelOle::Cell.new(self, self.Parent)
+            else
+              return RobustExcelOle::Range.new(self, self.Parent)
+            end
+          end
+        else
+          begin
+            recognising_method, no_method = methods
+            self.send(recognising_method)
+            unless no_method.nil?
+              begin
+                self.send(no_method[:no_method])
+                next
+              rescue NoMethodError
+                return classname.new(self)
+              end
+            end
+            if classname != RobustExcelOle::Range
+              return classname.new(self)
+            elsif self.Rows.Count == 1 && self.Columns.Count == 1
+              return RobustExcelOle::Cell.new(self, self.Parent)
+            else
+              return RobustExcelOle::Range.new(self, self.Parent)
+            end
+          rescue Java::OrgRacobCom::ComFailException => msg # NoMethodError
+            #if $!.message =~ /undefined method/ && 
+            #  main_classes_ole_types_and_recognising_methods.any?{ |_c, _o, recognising_method| $!.message.include?(recognising_method.to_s) }
+              next
+            #end 
           end
-        rescue
-          next
         end
       end
-      raise TypeREOError, "given object cannot be type-lifted to a RobustExcelOle object"
+      raise RobustExcelOle::TypeREOError, "given object cannot be type-lifted to a RobustExcelOle object"
     end
 
   end
-
 end
 
 # @private
@@ -43,6 +64,7 @@ module FindAllIndicesRefinement
   refine Array do
 
     def find_all_indices elem
+      elem = elem.encode('utf-8') if elem.respond_to?(:gsub)      
       found, index, result = -1, -1, []
       while found
         found = self[index+1..-1].index(elem)
@@ -58,39 +80,32 @@ module FindAllIndicesRefinement
 
 end
 
+TRANSLATION_TABLE = {
+      'ä' => 'ae', 'ö' => 'oe', 'ü' => 'ue', 'Ä' => 'Ae', 'Ö' => 'Oe', 'Ü' => 'Ue',
+      'ß' => 'ss', '²' => '2', '³' => '3'
+    }
+
 # @private
 module StringRefinement
 
   refine String do
 
     def / path_part
-      if empty?
-        path_part
-      else
-        if path_part.nil? || path_part.empty?
-          self
-        else
-          begin
-            path_part = path_part.strip
-            (path_part  =~ /^(\/|([A-Z]:\/))/i) ? path_part : (self.chomp('/') + '/' + path_part)
-          rescue TypeError
-            raise TypeError, "Only strings can be parts of paths (given: #{path_part.inspect} of class #{path_part.class})"
-          end
-        end
+      return path_part if empty?
+      return self if path_part.nil? || path_part.empty?
+      begin
+        path_part = path_part.strip
+        (path_part  =~ /^(\/|([A-Z]:\/))/i) ? path_part : (chomp('/') + '/' + path_part)
+      rescue TypeError
+        raise TypeError, "Only strings can be parts of paths (given: #{path_part.inspect} of class #{path_part.class})"
       end
-    end
+    end    
 
     def replace_umlauts
-      word = self.force_encoding('iso-8859-1').encode('utf-8')
-      #word = self.encode("UTF-8")
-      #word = self.encode("UTF-8", "Windows-1252")    
-      word.gsub('ä','ae').gsub('Ä','Ae').gsub('ö','oe').gsub('Ö','Oe').gsub('ü','ue').gsub('Ü','Ue')
-      word.gsub('ß','ss').gsub('²','2').gsub('³','3')      
-      #word.gsub("\x84",'ae').gsub("\x8E",'Ae').gsub("\x94",'oe').gsub("\x99",'Oe').gsub("\x81",'ue').gsub("\x9A",'Ue')
-      #word.gsub("\xE1",'ss').gsub("\xFD",'2').gsub("\xFC",'3')
-      word
+      TRANSLATION_TABLE.inject(encode('utf-8')) { |word,(umlaut, replacement)| word.gsub(umlaut, replacement) }
     end
 
+
     # taken from http://apidock.com/rails/ActiveSupport/Inflector/underscore
     def underscore
       word = gsub('::', '/')
@@ -163,7 +178,6 @@ class Integer
   alias old_spaceship <=>
 
   def <=> other
-    # p other
     if other.is_a? Array
       self <=> other.first
     else
@@ -201,6 +215,7 @@ module General
   ::ERRORMESSAGE_JRUBY_BUG  = IS_JRUBY_PLATFORM && true
   ::CONNECT_EXCEL_JRUBY_BUG = IS_JRUBY_PLATFORM && true
   ::RANGES_JRUBY_BUG        = IS_JRUBY_PLATFORM && true
+  ::OLETYPE_JRUBY_BUG       = IS_JRUBY_PLATFORM && true
 
   # @private
   NetworkDrive = Struct.new(:drive_letter, :network_name) do
@@ -208,12 +223,8 @@ module General
     def self.get_all_drives
       network = WIN32OLE.new('WScript.Network')
       drives = network.enumnetworkdrives
-      ndrives = []
       count = drives.Count
-      (0..(count - 1)).step(2) do |i|
-        ndrives << NetworkDrive.new( drives.Item(i), drives.Item(i + 1).tr('\\','/'))
-      end
-      ndrives
+      (0..(count - 1)).step(2).map{ |i| NetworkDrive.new( drives.Item(i), drives.Item(i + 1).tr('\\','/')) }
     end
   end
 
@@ -258,30 +269,46 @@ module General
   end
 
   # @private
-  def class2method
-    [{RobustExcelOle::Excel => :Hwnd},
-     {RobustExcelOle::Workbook => :FullName},
-     {RobustExcelOle::Worksheet => :UsedRange},
-     {RobustExcelOle::Range => :Row},
-     {RobustExcelOle::ListObject => :ListRows}]
+  def main_classes_ole_types_and_recognising_methods
+    [[RobustExcelOle::Range     , 'Range'       , :Row],
+     [RobustExcelOle::Worksheet , '_Worksheet'  , :UsedRange],
+     [RobustExcelOle::Workbook  , '_Workbook'   , :FullName],
+     [RobustExcelOle::Excel     , '_Application', :Hwnd],
+     [RobustExcelOle::ListObject, 'ListObject' , :ListRows],
+     [RobustExcelOle::ListRow   , 'ListRow'    , [:Creator, :no_method => :Row]]]
   end
 
   # @private
   # enable RobustExcelOle methods to Win32Ole objects
   def init_reo_for_win32ole
-    class2method.each do |element|
-      classname = element.first.first
+    main_classes_ole_types_and_recognising_methods.each do |classname, _ole_type, _recognising_method|
       meths = (classname.instance_methods(false) - WIN32OLE.instance_methods(false) - Object.methods - Enumerable.instance_methods(false) - [:Calculation=])
       meths.each do |inst_method|
-        WIN32OLE.send(:define_method, inst_method) do |*args, &blk|  
-          self.to_reo.send(inst_method, *args, &blk) 
+        if classname.method_defined?(inst_method)
+          WIN32OLE.send(:define_method, inst_method) do |*args, &blk|  
+            begin 
+              obj = to_reo                        
+            rescue
+              return self.send(inst_method.capitalize, *args, &blk)
+            end
+            obj.send(inst_method, *args, &blk)
+          end
+        else
+          WIN32OLE.send(:define_method, inst_method) do |*args, &blk|  
+            begin 
+              obj = classname.constantize.new(self)       
+            rescue
+              return self.send(inst_method.capitalize, *args, &blk)
+            end
+            obj.send(inst_method, *args, &blk) 
+          end
         end
       end
     end
-    nil
   end
 
-  module_function :absolute_path, :canonize, :normalize, :change_current_binding, :class2method, 
+  module_function :absolute_path, :canonize, :normalize, :change_current_binding, 
+                  :main_classes_ole_types_and_recognising_methods, 
                   :init_reo_for_win32ole, :hostnameshare2networkpath, :test
 
 end

data/lib/robust_excel_ole/list_object.rb

@@ -1,5 +1,4 @@
 # -*- coding: utf-8 -*-
-
 module RobustExcelOle
 
   using ToReoRefinement
@@ -12,6 +11,8 @@ module RobustExcelOle
 
   class ListObject < VbaObjects
 
+    include Enumerable
+
     attr_reader :ole_table
 
     alias ole_object ole_table
@@ -55,7 +56,7 @@ 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
 
@@ -73,32 +74,119 @@ module RobustExcelOle
 
     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
+
     # 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)
+    # @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
+
+  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 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          
+        @ole_table = ole_worksheet.table(self.Name)
+      end   
+      row_numbers
+    rescue
+      raise(TableError, "cannot find row with key #{key_hash}")
+    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    
@@ -106,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)                          # :nodoc: #
-      begin
-        @ole_table.ListRows.Item(row_number).Delete
-      rescue WIN32OLERuntimeError
-        raise TableError, "could not delete row #{row_number.inspect}"
-      end
+      @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)              # :nodoc: #
-      begin
-        @ole_table.ListColumns.Item(column_number_or_name).Delete
-      rescue WIN32OLERuntimeError
-        raise TableError, "could not delete column #{column_number_or_name.inspect}"
-      end
+      @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)              # :nodoc: #
-      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
+      @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
@@ -228,7 +296,7 @@ module RobustExcelOle
         if row.Range.Value == nil_array
           row.Delete
         else
-          i = i+1
+          i += 1
         end
       end
     end
@@ -243,7 +311,7 @@ module RobustExcelOle
         if column.Range.Value[1..-1] == nil_array
           column.Delete
         else
-          i = i+1
+          i += 1
         end
       end
     end
@@ -252,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_all_indices(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
@@ -274,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?
@@ -291,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
@@ -301,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
@@ -325,10 +402,6 @@ module RobustExcelOle
   class TableError < WorksheetREOError
   end
 
-  # @private
-  class TableRowError < WorksheetREOError
-  end
-
   Table = ListObject
 
 end