robust_excel_ole 1.20 → 1.23

data/lib/robust_excel_ole/cell.rb

@@ -12,26 +12,30 @@ module RobustExcelOle
       ole_cell
     end
 
-    def v
+    def value
       self.Value
     end
 
-    def v=(value)
+    def value=(value)
       self.Value = value
     end
 
+    alias_method :v, :value
+    alias_method :v=, :value=
+
+    # @private
     def ole_cell
       @ole_range = @ole_range.MergeArea.Item(1,1) if @ole_range.MergeCells
     end
 
     # @private
     def to_s    
-      @ole_table.Name.to_s
+      "#<Cell:" + " (#{@ole_range.Row},#{@ole_range.Column})" + ">"
     end
 
     # @private
-    def inspect    
-      "#<Cell:" + " (#{@ole_range.Row},#{@ole_range.Column})" + ">#" 
+    def inspect 
+      self.to_s[0..-2] + " #{@ole_range.Parent.Name}" + ">" 
     end
 
   private

data/lib/robust_excel_ole/cell.rbs

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+
+module RobustExcelOle
+
+  class Cell < Range
+
+    def initialize: (win32_cell: WIN32OLE, worksheet: Worksheet) -> void     
+
+    def value -> String
+
+    def value= (value: Variant) -> Variant
+
+    def v -> String
+    
+    def v= (value: Variant) -> Variant
+
+    def ole_cell -> WIN32OLE | void
+
+    def to_s -> String   
+
+    def inspect -> String 
+
+  end
+
+end

data/lib/robust_excel_ole/excel.rb

@@ -640,13 +640,8 @@ module RobustExcelOle
     # set options in this Excel instance
     def for_this_instance(options)
       set_options(options)
-      #self.class.new(@ole_excel, options)
     end
 
-    #def set_options(options)
-    #  for_this_instance(options)
-    #end  
-
     def set_options(options)      
       @properties ||= { }
       PROPERTIES.each do |property|
@@ -701,7 +696,7 @@ module RobustExcelOle
     # @param [String]  name  the name of the range
     # @param [Variant] value the contents of the range
     def []=(name, value)
-      set_namevalue_glob(name, value, :color => 42)
+      set_namevalue_glob(name, value)
     end
 
     # @private

data/lib/robust_excel_ole/general.rb

@@ -10,13 +10,14 @@ module General
   ::CONNECT_EXCEL_JRUBY_BUG      = IS_JRUBY_PLATFORM && true
   ::RANGES_JRUBY_BUG       = IS_JRUBY_PLATFORM && true
 
+  @private
   NetworkDrive = Struct.new(:drive_letter, :network_name) do
 
     def self.get_all(drives)
       ndrives = []
       count = drives.Count
       (0..(count - 1)).step(2) do |i|
-        ndrives << NetworkDrive.new( drives.Item(i), drives.Item(i + 1))
+        ndrives << NetworkDrive.new( drives.Item(i), drives.Item(i + 1).tr('\\','/'))
       end
       ndrives
     end
@@ -24,65 +25,22 @@ module General
   end
 
   @private
-  def network2hostnamesharepath(filename)
+  def hostnameshare2networkpath(filename)
+    return filename unless filename[0,2] == "//"
     network = WIN32OLE.new('WScript.Network')
     drives = network.enumnetworkdrives
-    drive_letter, filename_after_drive_letter = filename.split(':')
-    drive_letter = normalize_drive_letter(drive_letter)
     network_drives = NetworkDrive.get_all(drives)
-    network_drive = network_drives.find{ |d| d.drive_letter == drive_letter }
-    return filename unless network_drive
-    return network_drive.network_name + filename_after_drive_letter
-  end
-
-  def self.normalize_drive_letter(drive)
-    drive.upcase.end_with?(':') ? drive : "#{drive}:"
-  end
-
-  
-=begin
-  NetworkDrive = Struct.new(:drive_letter, :network_name)
-
-  @private
-  def network2hostnamesharepath(filename)
-    puts "network2hostnamesharepath:"
-    puts "filename: #{filename}"
-    network = WIN32OLE.new('WScript.Network')
-    drives = network.enumnetworkdrives
-    puts "drives: #{drives.inspect}"
-    drive_letter, filename_after_drive_letter = filename.split(':')
-    puts "drive_letter: #{drive_letter.inspect}"
-    puts "filename_after_drive_letter: #{filename_after_drive_letter.inspect}"
-    drive_letter = normalize_drive_letter(drive_letter)
-    puts "drive_letter: #{drive_letter.inspect}"
-    network_drives = get_network_drives
-    puts "network_drives: #{network_drives.inspect}"
-    network_drive = network_drives.find{ |d| d.drive_letter == drive_letter }
-    puts "network_drive: #{network_drive.inspect}"
-    return filename unless network_drive
-    #return (File.exists?(filename) ? filename : nil) unless network_drive 
-    return network_drive.network_name + filename_after_drive_letter
-  end
-
-  def get_network_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))
-    end
-    ndrives
-  end
-
-  def normalize_drive_letter(drive)
-    drive.upcase.end_with?(':') ? drive : "#{drive}:"
-  end
-
-=end
+    f_c = filename.dup
+    network_drive = network_drives.find do |d| 
+      e = f_c.sub!(d.network_name,d.drive_letter)
+      return e if e
+    end    
+    filename 
+  end  
 
   # @private
-  def absolute_path(file)     
+  def absolute_path(file)    
+    return file if file[0,2] == "//" 
     file[0,2] = './' if ::EXPANDPATH_JRUBY_BUG && file  =~ /[A-Z]:[^\/]/
     file = File.expand_path(file)
     file = RobustExcelOle::Cygwin.cygpath('-w', file) if RUBY_PLATFORM =~ /cygwin/
@@ -92,8 +50,8 @@ module General
   # @private
   def canonize(filename)
     raise TypeREOError, "No string given to canonize, but #{filename.inspect}" unless filename.is_a?(String)
-    filename = network2hostnamesharepath(filename)
-    normalize(filename).downcase if filename
+    filename = hostnameshare2networkpath(filename)
+    normalize(filename) if filename
   end
 
   # @private
@@ -163,7 +121,7 @@ class WIN32OLE
     class2method = [
       {Excel => :Hwnd},
       {Workbook => :FullName},
-      {Worksheet => :Copy},
+      {Worksheet => :UsedRange},
       {RobustExcelOle::Range => :Row},
       {ListObject => :ListRows}
     ]
@@ -224,6 +182,31 @@ class ::String
     word
   end
 
+  def delete_multiple_underscores
+    word = self
+    while word.index('__') do
+      word.gsub!('__','_')
+    end    
+    word
+  end
+
+  def replace_umlauts
+    word = self
+    word.gsub!('ä','ae')
+    word.gsub!('Ä','Ae')
+    word.gsub!('ö','oe')
+    word.gsub!('Ö','Oe')
+    word.gsub!('ü','ue')
+    word.gsub!('Ü','Ue')
+    #word.gsub!(/\x84/,'ae')
+    #word.gsub!(/\x8E/,'Ae')
+    #word.gsub!(/\x94/,'oe')
+    #word.gsub!(/\x99/,'Oe')
+    #word.gsub!(/\x81/,'ue')
+    #word.gsub!(/\x9A/,'Ue')
+    word
+  end
+
   # taken from http://apidock.com/rails/ActiveSupport/Inflector/constantize
   # File activesupport/lib/active_support/inflector/methods.rb, line 226
   def constantize # (camel_cased_word)

data/lib/robust_excel_ole/list_object.rb

@@ -14,24 +14,33 @@ 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] worksheet_or_listobject      a worksheet or a list object
     # @param [Variable] table_name_or_number         a table name or table number
     # @param [Array]    position                     a position of the upper left corner
     # @param [Integer]  rows_count                   number of rows
     # @param [Variable] columns_count_or_names       number of columns or array of column names
     # @return [ListObject] a ListObject object
-    def initialize(worksheet_or_ole_listobject,
-                   table_name_or_number = "",
+    def initialize(worksheet_or_listobject,
+                   table_name_or_number = "_table_name",
                    position = [1,1],
                    rows_count = 1, 
                    columns_count_or_names = 1)
-                   
-      if (worksheet_or_ole_listobject.ListRows rescue nil)
-        @ole_table = worksheet_or_ole_listobject
+
+      # ole_table is being assigned to the first parameter, if this parameter is a ListObject
+      # otherwise the first parameter could be a worksheet, and get the ole_table via the ListObject name or number
+      @ole_table = if worksheet_or_listobject.respond_to?(:ListRows)
+        worksheet_or_listobject.ole_table
       else
-        @worksheet = worksheet_or_ole_listobject.to_reo
-        @ole_table = @worksheet.ListObjects.Item(table_name_or_number) rescue nil
+        begin
+          worksheet_or_listobject.send(:ListRows)
+          worksheet_or_listobject
+        rescue
+          @worksheet = worksheet_or_listobject.to_reo
+          @worksheet.ListObjects.Item(table_name_or_number) rescue nil
+        end
       end
       unless @ole_table
         columns_count = 
@@ -50,6 +59,7 @@ module RobustExcelOle
         end
       end
 
+
       ole_table = @ole_table
       @row_class = Class.new(ListRow) do
 
@@ -115,31 +125,42 @@ module RobustExcelOle
             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.Item(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
@@ -349,6 +370,16 @@ module RobustExcelOle
       @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
     def to_s    
       @ole_table.Name.to_s
@@ -361,6 +392,8 @@ module RobustExcelOle
       " #{@ole_table.Parent.Name}" + " #{@ole_table.Parent.Parent.Name}" + ">"
     end
 
+    include MethodHelpers
+
   private
 
     def method_missing(name, *args) 

data/lib/robust_excel_ole/range.rb

@@ -5,17 +5,29 @@ module RobustExcelOle
   # This class essentially wraps a Win32Ole Range object. 
   # You can apply all VBA methods (starting with a capital letter) 
   # that you would apply for a Range object. 
-  # See https://docs.microsoft.com/en-us/office/vba/api/excel.worksheet#methods
+  # See https://docs.microsoft.com/en-us/office/vba/api/excel.range#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)
+    end
+
+    def rows
+      @rows ||= (1..@ole_range.Rows.Count)
+    end
+
+    def columns
+      @columns ||= (1..@ole_range.Columns.Count)
     end
 
     def each
@@ -43,7 +55,6 @@ module RobustExcelOle
     # @params [Range] a range
     # @returns [Array] the values
     def values(range = nil)
-      #result = map { |x| x.Value }.flatten
       result_unflatten = if !::RANGES_JRUBY_BUG
         map { |x| x.v }
       else
@@ -59,17 +70,17 @@ module RobustExcelOle
       end
     end
 
-    def v
+    # returns flat array of the values of a given range
+    # @returns [Array] values of the range (as a nested array)    
+    def value
       begin
         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
@@ -80,150 +91,101 @@ module RobustExcelOle
 
     end
 
-    def v=(value)
+    # sets the values if the range
+    # @param [Variant] value
+    def value=(value)
       begin
         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
         end
         value
       rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg  
-        raise RangeNotEvaluatable, "cannot assign value to range #{address_r1c1.inspect}"
+        raise RangeNotEvaluatable, "cannot assign value to range #{self.inspect}"
       end
     end
 
-    alias_method :value, :v
-    alias_method :value=, :v=
+    alias_method :v, :value
+    alias_method :v=, :value=
 
-    # copies a range
-    # @params [Address or Address-Array] address or upper left position of the destination range
-    # @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
-        else
-          @worksheet
-        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
-        else
-          { }
-        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]
-        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)
+    # 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 options[:values_only]
-          # dest_range.Value = options[:transpose] ? self.Value.transpose : self.Value
-          dest_range.v = options[:transpose] ? self.v.transpose : self.v
+        if !::RANGES_JRUBY_BUG
+          ole_range.Value = value
         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
-            if options[:transpose]
-              added_sheet = @worksheet.workbook.add_sheet
-              self.copy_special(dest_address, added_sheet, :transpose => true)
-              added_sheet.range(dest_range_address).copy_special(dest_address,dest_sheet)
-              @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)
+          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
         end
-      rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
-        raise RangeNotCopied, 'cannot copy range'
+        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
     end
 
-    # becomes copy
     # copies a range
     # @params [Address or Address-Array] address or upper left position of the destination range
     # @options [Worksheet] the destination worksheet
     # @options [Hash] options: :transpose, :values_only
-    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_range_address = if (not dest_address_is_position) 
+    def copy(dest_address, *remaining_args)
+      dest_sheet = @worksheet
+      options = { }
+      remaining_args.each do |arg|
+        case arg
+        when Object::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]
         else
           if (not options[:transpose])
-            [rows.min..rows.min+self.Rows.Count-1,
-             columns.min..columns.min+self.Columns.Count-1]
+            [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]
+            [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
+        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 dest_range.worksheet.workbook.excel == @worksheet.workbook.excel 
             if options[:transpose]
-              self.Copy
-              #dest_range.PasteSpecial('transpose' => true) 
+              self.Copy              
               dest_range.PasteSpecial(XlPasteAll,XlPasteSpecialOperationNone,false,true)
             else
-              #self.Copy('destination' => dest_range.ole_range)
               self.Copy(dest_range.ole_range)
             end            
           else
             if options[:transpose]
               added_sheet = @worksheet.workbook.add_sheet
-              self.copy_special(dest_address, added_sheet, :transpose => true)
-              added_sheet.range(dest_range_address).copy_special(dest_address,dest_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('destination' => dest_range.ole_range)
               dest_sheet.Paste(dest_range.ole_range)
             end
           end
         end
-      rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg 
+        dest_range
+      rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
         raise RangeNotCopied, 'cannot copy range'
       end
     end
@@ -239,6 +201,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: " + "#{@ole_range.Address('External' => true).gsub(/\$/,'')} " + ">"
+    end
+
+    # @private
+    def inspect
+      to_s
+    end
+
     # @private
     def self.worksheet_class   
       @worksheet_class ||= begin
@@ -254,6 +236,8 @@ module RobustExcelOle
       self.class.worksheet_class
     end
 
+    include MethodHelpers
+
   private
 
     def method_missing(name, *args)