robust_excel_ole 1.21 → 1.24

data/lib/robust_excel_ole/bookstore.rb

@@ -32,7 +32,7 @@ module RobustExcelOle
     def fetch(filename, options = { :prefer_writable => true })
       return nil unless filename
       filename = General.absolute_path(filename)
-      filename_key = General.canonize(filename)
+      filename_key = General.canonize(filename).downcase
       weakref_books = @filename2books[filename_key]
       return nil if weakref_books.nil? || weakref_books.empty?
 
@@ -70,9 +70,9 @@ module RobustExcelOle
     # stores a workbook
     # @param [Workbook] book a given book
     def store(book)
-      filename_key = General.canonize(book.filename)
+      filename_key = General.canonize(book.filename).downcase
       if book.stored_filename
-        old_filename_key = General.canonize(book.stored_filename)
+        old_filename_key = General.canonize(book.stored_filename).downcase
         # deletes the weak reference to the book
         @filename2books[old_filename_key].delete(book)
       end

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_range.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,23 +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
+    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  
 
-  def self.normalize_drive_letter(drive)
-    drive.upcase.end_with?(':') ? drive : "#{drive}:"
-  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/
@@ -50,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
@@ -142,16 +142,33 @@ class WIN32OLE
     raise TypeREOError, "given object cannot be type-lifted to a RobustExcelOle object"
   end
 
-  alias method_missing_before_implicit_typelift method_missing 
-  def xx_method_missing(name, *args, &blk)
-    begin
-      reo_obj = self.to_reo
-    rescue
-      puts "$!.message: #{$!.message}"
-      method_missing_before_implicit_typelift(name, *args, &blk)
-    end
-    reo_obj.send(name, *args, &blk)
-  end
+
+ # def method_missing(name, *args, &blk)
+ #   puts "method_missing:"
+ #   puts "name: #{name.inspect}"
+ #   puts "self: #{self}"
+ #   puts "self.ole_type: #{self.ole_type}"
+ #   puts "self.to_reo: #{self.to_reo}"
+ #   begin
+ #     reo_obj = self.to_reo
+ #   rescue
+ #     puts "error: #{$!.message}"
+ #     raise # NoMethodError, "undefined method #{name.inspect} for #{self.inspect}"
+ #   end
+ #   reo_obj.send(name, *args, &blk)
+ # end
+
+  #alias method_missing_before_implicit_typelift method_missing 
+  #def method_missing(name, *args, &blk)
+  #  begin
+  #    reo_obj = self.to_reo
+  #  rescue
+  #    puts "$!.message: #{$!.message}"
+  #    method_missing_before_implicit_typelift(name, *args, &blk)
+  #  end
+  #  reo_obj.send(name, *args, &blk)
+  #end
+
 end
 
 # @private

data/lib/robust_excel_ole/list_object.rb

@@ -17,23 +17,30 @@ module RobustExcelOle
     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 = 
@@ -52,6 +59,7 @@ module RobustExcelOle
         end
       end
 
+
       ole_table = @ole_table
       @row_class = Class.new(ListRow) do
 

data/lib/robust_excel_ole/range.rb

@@ -5,7 +5,7 @@ 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
 
@@ -20,8 +20,14 @@ module RobustExcelOle
     def initialize(win32_range, worksheet = nil)
       @ole_range = win32_range
       @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 rows
+      @rows ||= (1..@ole_range.Rows.Count)
+    end
+
+    def columns
+      @columns ||= (1..@ole_range.Columns.Count)
     end
 
     def each
@@ -49,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
@@ -65,15 +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
           values = []
-          @rows.each do |r|
+          rows.each do |r|
             values_col = []
-            @columns.each{ |c| values_col << worksheet.Cells(r,c).Value}
+            columns.each{ |c| values_col << worksheet.Cells(r,c).Value}
             values << values_col
           end
           values
@@ -84,144 +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
-          @rows.each_with_index do |r,i|
-            @columns.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)
+    # 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
-        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) 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
-        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)
-        if options[:values_only]
-          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(XlPasteAll,XlPasteSpecialOperationNone,false,true)
-            else
-              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(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
@@ -249,12 +213,12 @@ module RobustExcelOle
 
     # @private
     def to_s
-      "#<REO::Range: " + "[#{@rows},#{@columns}] " + "#{worksheet.Name} " + ">"
+      "#<REO::Range: " + "#{@ole_range.Address('External' => true).gsub(/\$/,'')} " + ">"
     end
 
     # @private
     def inspect
-      self.to_s
+      to_s
     end
 
     # @private