robust_excel_ole 1.31 → 1.32

data/lib/robust_excel_ole/address_tool.rb

@@ -16,71 +16,80 @@ module RobustExcelOle
     #   integer_ranges-fromat: e.g. [3,1], [3,"A"], [3..5,1..2], [3..5, "A".."B"], 
     #                               [3..4, nil], [nil, 2..4], [2,nil], [nil,4]
     #   a1-format: e.g. "A3", "A3:B5", "A:B", "3:5", "A", "3"
-
     def as_r1c1(address)
-      transform_address(address,:r1c1)
+      transform_address(address, :r1c1)
     end
 
     def as_a1(address)
-      transform_address(address,:a1)
+      transform_address(address, :a1)
     end
 
     # valid address formats: e.g. [3,1], [3,"A"], [3..5,1..2], [3..5, "A".."B"], 
     #                             [3..4, nil], [nil, 2..4], [2,nil], [nil,4]
     def as_integer_ranges(address)
-      transform_address(address,:int_range)
+      transform_address(address, :int_range)
     end
-
+   
   private
 
     def transform_address(address, format)
       address = address.is_a?(Array) ? address : [address]
       raise AddressInvalid, "address #{address.inspect} has more than two components" if address.size > 2
-      begin
-        if address.size == 1
-          comp1, comp2 = address[0].split(':')
-          a1_expr = /^(([A-Z]+[0-9]+)|([A-Z]+$)|([0-9]+))$/
-          is_a1 = comp1 =~ a1_expr && (comp2.nil? || comp2 =~ a1_expr)
-          r1c1_expr = /^(([A-Z]\[?-?[0-9]+\]?[A-Z]\[?-?[0-9]+\]?)|([A-Z]\[?-?[0-9]+\]?)|([A-Z]\[?-?[0-9]+\]?))$/
-          is_r1c1 = comp1 =~ r1c1_expr && (comp2.nil? || comp2 =~ r1c1_expr) && (not is_a1) 
-          raise AddressInvalid, "address #{address.inspect} not in A1- or r1c1-format" unless (is_a1 || is_r1c1)
-          return address[0].gsub('[','(').gsub(']',')') if (is_a1 && format==:a1) || (is_r1c1 && format==:r1c1)         
-          given_format = (is_a1) ? :a1 : :r1c1
-          row_comp1, col_comp1 = analyze(comp1,given_format)
-          row_comp2, col_comp2 = analyze(comp2,given_format) unless comp2.nil?
-          address_comp1 = comp2 && (not row_comp1.nil?) ? (row_comp1 .. row_comp2) : row_comp1
-          address_comp2 = comp2 && (not col_comp1.nil?) ? (col_comp1 .. col_comp2) : col_comp1          
-        else
-          address_comp1, address_comp2 = address      
-        end
-        address_comp1 = address_comp1..address_comp1 if (address_comp1.is_a?(Integer) || address_comp1.is_a?(String) || address_comp1.is_a?(Array))
-        address_comp2 = address_comp2..address_comp2 if (address_comp2.is_a?(Integer) || address_comp2.is_a?(String) || address_comp2.is_a?(Array)) 
-        #raise unless address_comp1.nil? || address_comp1.begin.to_i!=0 || address_comp1.begin.empty?
-        rows = unless address_comp1.nil? || address_comp1.begin == 0 # || address_comp1.begin.to_i==0          
-          address_comp1.begin..address_comp1.end
-        end
-        columns = unless address_comp2.nil?
-          if address_comp2.begin.is_a?(String) #address_comp2.begin.to_i == 0
-            col_range = str2num(address_comp2.begin)..str2num(address_comp2.end)
-            col_range==(0..0) ? nil : col_range
-          else
-            address_comp2.begin..address_comp2.end
-          end          
-        end
-      rescue
-        raise AddressInvalid, "address (#{address.inspect}) format not correct"
+      rows, columns = begin
+        rows_and_columns(address, format)
+      rescue AddressInvalid
+        raise
+      rescue AddressAlreadyInRightFormat
+        return address[0].gsub('[','(').gsub(']',')') 
       end
-      if format==:r1c1
+      if format == :int_range
+        [rows,columns]
+      elsif format == :r1c1
         r1c1_string(@row_letter,rows,:min) + r1c1_string(@col_letter,columns,:min) + ":" + 
         r1c1_string(@row_letter,rows,:max) + r1c1_string(@col_letter,columns,:max)
-      elsif format==:int_range
-        [rows,columns]
       else
         raise NotImplementedREOError, "not implemented"
       end
-    end  
+    end
+
+    def rows_and_columns(address, format)
+      if address.size != 1
+        address_comp1, address_comp2 = address      
+      else
+        comp1, comp2 = address[0].split(':')
+        a1_expr = /^(([A-Z]+[0-9]+)|([A-Z]+$)|([0-9]+))$/
+        is_a1 = comp1 =~ a1_expr && (comp2.nil? || comp2 =~ a1_expr)
+        r1c1_expr = /^(([A-Z]\[?-?[0-9]+\]?[A-Z]\[?-?[0-9]+\]?)|([A-Z]\[?-?[0-9]+\]?)|([A-Z]\[?-?[0-9]+\]?))$/
+        is_r1c1 = comp1 =~ r1c1_expr && (comp2.nil? || comp2 =~ r1c1_expr) && (not is_a1) 
+        raise AddressInvalid, "address #{address.inspect} not in A1- or r1c1-format" unless (is_a1 || is_r1c1)
+        raise AddressAlreadyInRightFormat if (is_a1 && format==:a1) || (is_r1c1 && format==:r1c1)   
+        given_format = (is_a1) ? :a1 : :r1c1
+        row_comp1, col_comp1 = analyze(comp1,given_format)
+        row_comp2, col_comp2 = analyze(comp2,given_format) unless comp2.nil?
+        address_comp1 = comp2 && (not row_comp1.nil?) ? (row_comp1 .. row_comp2) : row_comp1
+        address_comp2 = comp2 && (not col_comp1.nil?) ? (col_comp1 .. col_comp2) : col_comp1          
+      end
+      address_comp1 = address_comp1..address_comp1 if (address_comp1.is_a?(Integer) || address_comp1.is_a?(String) || address_comp1.is_a?(Array))
+      address_comp2 = address_comp2..address_comp2 if (address_comp2.is_a?(Integer) || address_comp2.is_a?(String) || address_comp2.is_a?(Array))
+      raise AddressInvalid, "address contains row 0" if !address_comp1.nil? && address_comp1.begin == 0
+      rows = address_comp1.begin..address_comp1.end unless address_comp1.nil? || address_comp1.begin == 0
+      columns = unless address_comp2.nil?
+        if address_comp2.begin.is_a?(String) #address_comp2.begin.to_i == 0
+          col_range = str2num(address_comp2.begin)..str2num(address_comp2.end)
+          col_range==(0..0) ? nil : col_range
+        else
+          address_comp2.begin..address_comp2.end
+        end          
+      end
+      [rows, columns]
+    rescue
+      raise AddressInvalid, "address (#{address.inspect}) format not correct"
+    end
 
-    def r1c1_string(letter,int_range,type)
+    class AddressAlreadyInRightFormat < Exception
+    end
+    
+    def r1c1_string(letter, int_range,type)
       return "" if int_range.nil? || int_range.begin.nil?
       parameter = type == :min ? int_range.begin : int_range.end
       is_relative = parameter.is_a?(Array)
@@ -88,7 +97,7 @@ module RobustExcelOle
       letter + (is_relative ? "(" : "") + parameter.to_s + (is_relative ? ")" : "")       
     end 
 
-    def analyze(comp,format)
+    def analyze(comp, format)
       row_comp, col_comp = if format==:a1 
         [comp.gsub(/[A-Z]/,''), comp.gsub(/[0-9]/,'')]
       else
@@ -108,6 +117,7 @@ module RobustExcelOle
 
   end
 
+
   # @private
   class AddressInvalid < REOError                  
   end

data/lib/robust_excel_ole/base.rb

@@ -69,7 +69,7 @@ module RobustExcelOle
 
     # @private
     def own_methods
-      (self.methods - Object.methods).sort
+      (methods - Object.methods).sort
     end
 
     # @private
@@ -99,12 +99,10 @@ module RobustExcelOle
     def self.puts_hash(hash)
       hash.each do |e|
         if e[1].is_a?(Hash)
-          puts "#{e[0]} =>"
-          e[1].each do |f|
-            puts "  #{f[0]} => #{f[1]}"
-          end
+          puts "#{e[0]}: "
+          e[1].each{ |f| puts "  #{f[0]}: #{f[1]}" }
         else
-          puts "#{e[0]} => #{e[1]}"
+          puts "#{e[0]}: #{e[1]}"
         end
       end
     end

data/lib/robust_excel_ole/bookstore.rb

@@ -29,19 +29,17 @@ module RobustExcelOle
     #                             otherwise returns the workbook according to the preference order mentioned above
     #          :prefer_excel      returns the workbook in the given Excel instance, if it exists,
     #                             otherwise proceeds according to prefer_writable
-    def fetch(filename, options = { :prefer_writable => true })
+    def fetch(filename, options = { prefer_writable: true })
       return nil unless filename
       filename = General.absolute_path(filename)
       filename_key = General.canonize(filename).downcase
       weakref_books = @filename2books[filename_key]
       return nil if weakref_books.nil? || weakref_books.empty?
-
       result = open_book = closed_book = nil
       weakref_books = weakref_books.map { |wr_book| wr_book if wr_book.weakref_alive? }.compact
       @filename2books[filename_key] = weakref_books
       weakref_books.each do |wr_book|
         if !wr_book.weakref_alive?
-          # trace "warn: this should never happen"
           begin
             @filename2books[filename_key].delete(wr_book)
           rescue
@@ -50,7 +48,6 @@ module RobustExcelOle
         else
           book = wr_book.__getobj__
           next if book.excel == try_hidden_excel
-
           if options[:prefer_excel] && book.excel == options[:prefer_excel]
             result = book
             break
@@ -64,7 +61,6 @@ module RobustExcelOle
         end
       end
       result ||= (open_book || closed_book)
-      result
     end
 
     # stores a workbook
@@ -90,17 +86,7 @@ module RobustExcelOle
 
     # returns all stored books
     def books
-      result = []
-      if @filename2books
-        @filename2books.each do |_filename,books|
-          next if books.empty?
-
-          books.each do |wr_book|
-            result << wr_book.__getobj__ if wr_book.weakref_alive?
-          end
-        end
-      end
-      result
+      @filename2books.map{ |_fn,books| books.map{ |wr_bk| wr_bk.__getobj__ if wr_bk.weakref_alive?}.compact}.flatten
     end
 
   private

data/lib/robust_excel_ole/cell.rb

@@ -7,7 +7,7 @@ module RobustExcelOle
   class Cell < Range
     #attr_reader :ole_cell    
 
-    def initialize(win32_cell, worksheet)      
+    def initialize(win32_cell, worksheet)
       super
       ole_cell
     end
@@ -20,8 +20,8 @@ module RobustExcelOle
       self.Value = value
     end
 
-    alias_method :v, :value
-    alias_method :v=, :value=
+    alias v value
+    alias v= value=
 
     # @private
     def ole_cell
@@ -30,36 +30,31 @@ module RobustExcelOle
 
     # @private
     def to_s    
-      "#<Cell:" + " (#{@ole_range.Row},#{@ole_range.Column})" + ">"
+      "#<Cell: (#{@ole_range.Row},#{@ole_range.Column})>"
     end
 
     # @private
     def inspect 
-      self.to_s[0..-2] + " #{@ole_range.Parent.Name}" + ">" 
+      to_s[0..-2] + " #{@ole_range.Parent.Name}>" 
     end
 
   private
 
     # @private
     def method_missing(name, *args) 
-      if name.to_s[0,1] =~ /[A-Z]/
-        if ::ERRORMESSAGE_JRUBY_BUG
-          begin
-            #@ole_cell.send(name, *args)
-            @ole_range.send(name, *args)
-          rescue Java::OrgRacobCom::ComFailException 
-            raise VBAMethodMissingError, "unknown VBA property or method #{name.inspect}"
-          end
-        else
-          begin
-            #@ole_cell.send(name, *args)
-            @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

data/lib/robust_excel_ole/excel.rb

@@ -16,6 +16,8 @@ module RobustExcelOle
 
   class Excel < VbaObjects
 
+    include Enumerable
+
     attr_reader :ole_excel
     attr_reader :properties
     attr_reader :address_tool
@@ -34,7 +36,7 @@ module RobustExcelOle
     # @option options [Boolean] :screenupdating
     # @return [Excel] a new Excel instance
     def self.create(options = {})
-      new(options.merge(:reuse => false))
+      new(options.merge(reuse: false))
     end
 
     # connects to the current (first opened) Excel instance, if such a running Excel instance exists
@@ -45,7 +47,7 @@ module RobustExcelOle
     # @option options [Boolean] :screenupdating
     # @return [Excel] an Excel instance
     def self.current(options = {})
-      new(options.merge(:reuse => true))
+      new(options.merge(reuse: true))
     end
 
     # returns an Excel instance
@@ -70,10 +72,11 @@ module RobustExcelOle
         options = win32ole_excel
         win32ole_excel = nil
       end
-      ole_xl = win32ole_excel unless win32ole_excel.nil?
-      options = { :reuse => true }.merge(options)
-      if options[:reuse] == true && ole_xl.nil?
-        ole_xl = current_ole_excel
+      options = { reuse: true }.merge(options)
+      ole_xl = if !win32ole_excel.nil? 
+        win32ole_excel
+      elsif options[:reuse] == true
+        current_ole_excel
       end
       connected = (not ole_xl.nil?) && win32ole_excel.nil?
       ole_xl ||= WIN32OLE.new('Excel.Application')
@@ -87,14 +90,9 @@ module RobustExcelOle
         WIN32OLE.const_load(ole_xl, RobustExcelOle) unless RobustExcelOle.const_defined?(:CONSTANTS)
         @@hwnd2excel[hwnd] = WeakRef.new(result)
       end
-
-      begin
-        reused = options[:reuse] && stored && stored.alive? 
-        unless reused || connected
-          options = { :displayalerts => :if_visible, :visible => false, :screenupdating => true }.merge(options)
-        end
-        result.set_options(options)        
-      end
+      reused = options[:reuse] && stored && stored.alive? 
+      options = { displayalerts: :if_visible, visible: false, screenupdating: true }.merge(options) unless reused || connected
+      result.set_options(options)        
       result
     end    
 
@@ -111,15 +109,12 @@ module RobustExcelOle
     # @return [Excel] an Excel instance
     def recreate(opts = {})
       unless alive?
-        opts = {:visible => false, :displayalerts => :if_visible}.merge(
-               {:visible => @properties[:visible], :displayalerts => @properties[:displayalerts]}).merge(opts)        
+        opts = {visible: false, displayalerts: :if_visible}.merge(
+               {visible: @properties[:visible], displayalerts: @properties[:displayalerts]}).merge(opts)        
         @ole_excel = WIN32OLE.new('Excel.Application')
         set_options(opts)
         if opts[:reopen_workbooks]
-          books = workbook_class.books
-          books.each do |book|
-            book.reopen if !book.alive? && book.excel.alive? && book.excel == self
-          end
+          workbook_class.books.each{ |book| book.reopen if !book.alive? && book.excel.alive? && book.excel == self }
         end
       end
       self
@@ -147,34 +142,29 @@ module RobustExcelOle
     end
 
     def ole_workbooks
-      ole_workbooks = begin
-        @ole_excel.Workbooks
-      rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
-        if msg.message =~ /failed to get Dispatch Interface/
-          raise ExcelDamaged, 'Excel instance not alive or damaged'
-        else
-          raise ExcelREOError, 'workbooks could not be determined'
-        end
+      @ole_excel.Workbooks
+    rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
+      if msg.message =~ /failed to get Dispatch Interface/
+        raise ExcelDamaged, "Excel instance not alive or damaged"
+      else
+        raise ExcelREOError, "workbooks could not be determined\n#{$!.message}"
       end
     end
 
   public
 
     # @private
+    # returns unsaved workbooks (win32ole objects)
     def self.contains_unsaved_workbooks?
       !Excel.current.unsaved_workbooks.empty?
     end
 
-    # returns unsaved workbooks (win32ole objects)
     # @private
+    # returns unsaved workbooks (win32ole objects)   
     def unsaved_workbooks
-      unsaved_workbooks = []
-      begin
-        @ole_excel.Workbooks.each { |w| unsaved_workbooks << w unless w.Saved || w.ReadOnly }
-      rescue RuntimeError => msg
-        raise ExcelDamaged, 'Excel instance not alive or damaged' if msg.message =~ /failed to get Dispatch Interface/
-      end
-      unsaved_workbooks
+      @ole_excel.Workbooks.reject { |w| w.Saved || w.ReadOnly }
+    rescue RuntimeError => msg
+      raise ExcelDamaged, "Excel instance not alive or damaged" if msg.message =~ /failed to get Dispatch Interface/
     end
 
     # closes workbooks
@@ -185,7 +175,7 @@ module RobustExcelOle
     #                      :save            -> saves the workbooks before closing
     #                      :alert           -> let Excel do it
     # @private
-    def close_workbooks(options = { :if_unsaved => :raise })
+    def close_workbooks(options = { if_unsaved: :raise })
       return unless alive?
 
       weak_wkbks = @ole_excel.Workbooks
@@ -208,11 +198,12 @@ module RobustExcelOle
           "\nHint: Valid values are :raise, :forget, :save and :alert"
         end
       end
+
       begin
         @ole_excel.Workbooks.Close
       rescue
         if $!.message =~ /kann nicht zugeordnet werden/ or $!.message =~ /800A03EC/
-          raise ExcelREOError, 'user canceled or runtime error'
+          raise ExcelREOError, "user canceled or runtime error"
         else
           raise UnexpectedREOError, "unknown WIN32OLERuntimeError: #{msg.message}"
         end
@@ -235,7 +226,7 @@ module RobustExcelOle
     #                      :forget          -> closes the excel instance without saving the workbooks
     #                      :alert           -> give control to Excel
     # @option options [Proc] block
-    def self.close_all(options = { :if_unsaved => :raise }, &blk)
+    def self.close_all(options = { if_unsaved: :raise }, &blk)
       options[:if_unsaved] = blk if blk
       finished_number = error_number = overall_number = 0
       first_error = nil
@@ -243,10 +234,9 @@ module RobustExcelOle
         if excel
           begin
             overall_number += 1
-            finished_number += excel.close(:if_unsaved => options[:if_unsaved])
+            finished_number += excel.close(if_unsaved: options[:if_unsaved])
           rescue
             first_error = $!
-            #trace "error when finishing #{$!}"
             error_number += 1
           end
         end
@@ -269,19 +259,13 @@ module RobustExcelOle
       old_error_number = error_number
       9.times do |_index|
         sleep 0.1
-        excel = begin
-                  new(WIN32OLE.connect('Excel.Application'))
-                rescue
-                  nil
-                end
+        excel = new(WIN32OLE.connect('Excel.Application')) rescue nil
         finishing_action.call(excel) if excel
         free_all_ole_objects unless (error_number > 0) && (options[:if_unsaved] == :raise)
         break unless excel
         break if error_number > old_error_number # + 3
       end
-
       raise first_error if ((options[:if_unsaved] == :raise) && first_error) || (first_error.class == OptionInvalid)
-
       [finished_number, error_number]
     end
 
@@ -294,19 +278,13 @@ module RobustExcelOle
     #                      :save            -> saves the workbooks before closing
     #                      :forget          -> closes the Excel instance without saving the workbooks
     #                      :alert           -> Excel takes over    
-    def close(options = { :if_unsaved => :raise })
+    def close(options = { if_unsaved: :raise })
       finishing_living_excel = alive?
       if finishing_living_excel
-        hwnd = (begin
-                  @ole_excel.Hwnd
-                rescue
-                  nil
-                end)
-        close_workbooks(:if_unsaved => options[:if_unsaved])
+        hwnd = @ole_excel.Hwnd rescue nil
+        close_workbooks(if_unsaved: options[:if_unsaved])
         @ole_excel.Quit
-        if false && defined?(weak_wkbks) && weak_wkbks.weakref_alive?
-          weak_wkbks.ole_free
-        end
+        weak_wkbks.ole_free if false && defined?(weak_wkbks) && weak_wkbks.weakref_alive?
         weak_xl = WeakRef.new(@ole_excel)
       else
         weak_xl = nil
@@ -320,21 +298,10 @@ module RobustExcelOle
           pid_puffer = ' ' * 32
           process_id.call(hwnd, pid_puffer)
           pid = pid_puffer.unpack('L')[0]
-          begin
-            Process.kill('KILL', pid)
-          rescue
-            # trace "kill_error: #{$!}"
-          end
+          Process.kill('KILL', pid) rescue nil
         end
         @@hwnd2excel.delete(hwnd)
-        if weak_xl.weakref_alive?
-          # if WIN32OLE.ole_reference_count(weak_xlapp) > 0
-          begin
-            weak_xl.ole_free
-          rescue
-            # trace "weakref_probl_olefree"
-          end
-        end
+        weak_xl.ole_free if weak_xl.weakref_alive?
       end
       weak_xl ? 1 : 0
     end
@@ -383,15 +350,42 @@ module RobustExcelOle
       number
     end
 
-    def self.excels_number
-      processes = WIN32OLE.connect('winmgmts:\\\\.').InstancesOf('win32_process')
-      processes.select { |p| p.Name == 'EXCEL.EXE' }.size
+    def self.instance_count
+      WIN32OLE.connect('winmgmts:\\\\.').InstancesOf('win32_process').select { |p| p.Name == 'EXCEL.EXE' }.size
     end
 
-    def self.known_excels_number
+    def self.known_instance_count
       @@hwnd2excel.size
     end
 
+    # returns a running Excel instance opened with RobustExcelOle
+    def self.known_running_instance     
+      self.known_running_instances.first
+    end
+
+    # @return [Enumerator] known running Excel instances
+    def self.known_running_instances
+      pid2excel = {}
+      @@hwnd2excel.each do |hwnd,wr_excel|
+        next unless wr_excel.weakref_alive?
+        excel = wr_excel.__getobj__
+        process_id = Win32API.new('user32', 'GetWindowThreadProcessId', %w[I P], 'I')
+        pid_puffer = ' ' * 32
+        process_id.call(hwnd, pid_puffer)
+        pid = pid_puffer.unpack('L')[0]
+        pid2excel[pid] = excel
+      end
+      processes = WIN32OLE.connect('winmgmts:\\\\.').InstancesOf('win32_process')     
+      processes.map{ |p| pid2excel[p.ProcessId] if p.Name == 'EXCEL.EXE'}.compact.lazy.each
+    end
+
+    class << self
+      alias excels_number instance_count                  # :deprecated :#
+      alias known_excels_number known_instance_count      # :deprecated :#
+      alias known_excel_instance known_running_instance   # :deprecated :#
+      alias known_excel_instances known_running_instances # :deprecated :#
+    end
+
   private
 
     # returns a Win32OLE object that represents a Excel instance to which Excel connects
@@ -399,7 +393,7 @@ module RobustExcelOle
     # if this Excel instance is being closed, then Excel creates a new Excel instance
     def self.current_ole_excel   
       if ::CONNECT_EXCEL_JRUBY_BUG
-        result = known_excel_instance
+        result = known_running_instance
         if result.nil?
           if excels_number > 0
             dummy_ole_workbook = WIN32OLE.connect(General.absolute_path('___dummy_workbook.xls')) rescue nil
@@ -428,17 +422,6 @@ module RobustExcelOle
       result
     end
 
-    # returns an Excel instance
-    def self.known_excel_instance
-      @@hwnd2excel.each do |hwnd, wr_excel|
-        if wr_excel.weakref_alive?
-          excel = wr_excel.__getobj__
-          return excel if excel.alive?
-        end
-      end
-      nil
-    end
-
     def self.hwnd2excel(hwnd)
       excel_weakref = @@hwnd2excel[hwnd]
       if excel_weakref
@@ -458,35 +441,6 @@ module RobustExcelOle
 
   public
 
-    # returns all Excel objects for all Excel instances opened with RobustExcelOle
-    def self.known_excel_instances
-      pid2excel = {}
-      @@hwnd2excel.each do |hwnd,wr_excel|
-        next unless wr_excel.weakref_alive?
-
-        excel = wr_excel.__getobj__
-        process_id = Win32API.new('user32', 'GetWindowThreadProcessId', %w[I P], 'I')
-        pid_puffer = ' ' * 32
-        process_id.call(hwnd, pid_puffer)
-        pid = pid_puffer.unpack('L')[0]
-        pid2excel[pid] = excel
-      end
-      processes = WIN32OLE.connect('winmgmts:\\\\.').InstancesOf('win32_process')
-      processes.select { |p| Excel.new(pid2excel[p.ProcessId]) if p.Name == 'EXCEL.EXE' && pid2excel.include?(p.ProcessId) }
-      result = []
-      processes.each do |p|
-        next unless p.Name == 'EXCEL.EXE'
-
-        if pid2excel.include?(p.ProcessId)
-          excel = pid2excel[p.ProcessId]
-          result << excel
-        end
-        # how to connect to an (interactively opened) Excel instance and get a WIN32OLE object?
-        # after that, lift it to an Excel object
-      end
-      result
-    end
-
     # @private
     def excel
       self
@@ -524,15 +478,11 @@ module RobustExcelOle
 
     # returns unsaved workbooks in known (not opened by user) Excel instances
     # @private
-    def self.unsaved_known_workbooks 
-      result = []
-      @@hwnd2excel.each do |_hwnd,wr_excel|
-        excel = wr_excel.__getobj__ if wr_excel.weakref_alive?
-        result << excel.unsaved_workbooks
-      end
-      result
+    def self.unsaved_known_workbooks       
+      @@hwnd2excel.values.map{ |wk_exl| wk_exl.__getobj__.unsaved_workbooks if wk_exl.weakref_alive? }.compact.flatten
     end
 
+
     # @private
     def print_workbooks
       self.Workbooks.each { |w| trace "#{w.Name} #{w}" }
@@ -540,7 +490,7 @@ module RobustExcelOle
 
     # @private
     def generate_workbook file_name  # :deprecated: #
-      workbook_class.open(file_name, :if_absent => :create, :force => {:excel => self})
+      workbook_class.open(file_name, if_absent: :create, force: {excel: self})
     end
 
     # sets DisplayAlerts in a block
@@ -580,37 +530,30 @@ module RobustExcelOle
       return if calculation_mode.nil?
       @properties[:calculation] = calculation_mode
       calc_mode_changable = @ole_excel.Workbooks.Count > 0 && @ole_excel.Calculation.is_a?(Integer)
-      if calc_mode_changable
-        retain_saved_workbooks do
-          begin
-            best_wb_to_make_visible = @ole_excel.Workbooks.sort_by {|wb|
-              score =
-                (wb.Saved    ? 0 : 40) +  # an unsaved workbooks is most likely the main workbook
-                (wb.ReadOnly ? 0 : 20) +  # the main wb is usually writable
-                case wb.Name.split(".").last.downcase
-                  when "xlsm" then 10  # the main workbook is more likely to have macros
-                  when "xls"  then  8
-                  when "xlsx" then  4
-                  when "xlam" then -2  # libraries are not normally the main workbook
-                  else 0
-                end
-              score
-            }.last
-            best_wb_to_make_visible.Windows(1).Visible = true
-          rescue => e
-            trace "error setting calculation=#{calculation_mode} msg: " + e.message
-            trace e.backtrace
-            # continue on errors here, failing would usually disrupt too much
-          end
-          saved = []
-          @ole_excel.Workbooks.each { |w| saved << w.Saved }
-          @ole_excel.CalculateBeforeSave = false
-          @ole_excel.Calculation =
-            calculation_mode == :automatic ? XlCalculationAutomatic : XlCalculationManual
-          saved = []
-          @ole_excel.Workbooks.each { |w| saved << w.Saved }
+      return unless calc_mode_changable
+      retain_saved_workbooks do
+        begin
+          best_wb_to_make_visible = @ole_excel.Workbooks.sort_by {|wb|
+            score =
+              (wb.Saved    ? 0 : 40) +  # an unsaved workbooks is most likely the main workbook
+              (wb.ReadOnly ? 0 : 20) +  # the main wb is usually writable
+              case wb.Name.split(".").last.downcase
+                when "xlsm" then 10  # the main workbook is more likely to have macros
+                when "xls"  then  8
+                when "xlsx" then  4
+                when "xlam" then -2  # libraries are not normally the main workbook
+                else 0
+              end
+            score
+          }.last
+          best_wb_to_make_visible.Windows(1).Visible = true
+        rescue => e
+          trace "error setting calculation=#{calculation_mode} msg: " + e.message
+          trace e.backtrace
+          # continue on errors here, failing would usually disrupt too much
         end
-        #(1..@ole_excel.Workbooks.Count).each { |i| @ole_excel.Workbooks(i).Saved = true if saved[i - 1] }
+        @ole_excel.CalculateBeforeSave = false
+        @ole_excel.Calculation = calculation_mode == :automatic ? XlCalculationAutomatic : XlCalculationManual
       end
     end
 
@@ -628,7 +571,6 @@ module RobustExcelOle
     # sets calculation mode in a block
     def with_calculation(calculation_mode)
       return unless calculation_mode
-
       old_calculation_mode = @ole_excel.Calculation
       begin
         self.calculation = calculation_mode
@@ -639,35 +581,39 @@ module RobustExcelOle
     end
 
     # set options in this Excel instance
-    def for_this_instance(options)
-      set_options(options)
-    end
-
     def set_options(options)      
       @properties ||= { }
       PROPERTIES.each do |property|
         method = (property.to_s + '=').to_sym
-        self.send(method, options[property]) 
+        send(method, options[property]) 
       end
     end
-  
-    # set options in all workbooks
-    def for_all_workbooks(options)
-      each_workbook(options)
+
+    alias for_this_instance set_options  # :deprecated: #    
+
+    # @return [Enumerator] traversing all workbook objects
+    def each
+      if block_given?
+        ole_workbooks.lazy.each do |ole_workbook|
+          yield workbook_class.new(ole_workbook)
+        end
+      else
+        to_enum(:each).lazy
+      end
     end
 
+    # @return [Array] all workbook objects
     def workbooks
-      #ole_workbooks.map {|ole_workbook| ole_workbook.to_reo }
-      ole_workbooks.map {|ole_workbook| workbook_class.new(ole_workbook) }
+      to_a
     end
 
-    # traverses over all workbooks and sets options if provided
+    # traverses all workbooks and sets options if provided
     def each_workbook(opts = { })
-      ole_workbooks.each do |ow|
+      ole_workbooks.lazy.each do |ow|
         wb = workbook_class.new(ow, opts)
         block_given? ? (yield wb) : wb
       end
-    end
+    end    
 
     def each_workbook_with_index(opts = { }, offset = 0)
       i = offset
@@ -677,6 +623,8 @@ module RobustExcelOle
       end
     end
 
+    alias for_all_workbooks each_workbook   # :deprecated: #
+
     def focus
       self.visible = true
       # if not Windows10 then
@@ -692,11 +640,11 @@ module RobustExcelOle
       @workbook ||= workbook_class.new(@ole_excel.ActiveWorkbook) if @ole_excel.Workbooks.Count > 0
     end    
 
-    alias_method :active_workbook, :workbook
+    alias active_workbook workbook
 
     # @private
     def to_s            
-      '#<Excel: ' + hwnd.to_s + ('not alive' unless alive?).to_s + '>'
+      "#<Excel: #{hwnd}#{ ("not alive" unless alive?)}>"
     end
 
     # @private
@@ -743,23 +691,20 @@ module RobustExcelOle
   private
 
     def method_missing(name, *args) 
-      if name.to_s[0,1] =~ /[A-Z]/
-        raise ObjectNotAlive, 'method missing: Excel not alive' unless alive?
-        if ::ERRORMESSAGE_JRUBY_BUG
-          begin
-            @ole_excel.send(name, *args)
-          rescue Java::OrgRacobCom::ComFailException => msg
-            raise VBAMethodMissingError, "unknown VBA property or method #{name.inspect}"
-          end
-        else
-          begin
-            @ole_excel.send(name, *args)
-          rescue NoMethodError
-            raise VBAMethodMissingError, "unknown VBA property or method #{name.inspect}"
-          end
+      super unless name.to_s[0,1] =~ /[A-Z]/
+      raise ObjectNotAlive, 'method missing: Excel not alive' unless alive?
+      if ::ERRORMESSAGE_JRUBY_BUG
+        begin
+          @ole_excel.send(name, *args)
+        rescue Java::OrgRacobCom::ComFailException
+          raise VBAMethodMissingError, "unknown VBA property or method #{name.inspect}"
         end
       else
-        super
+        begin
+          @ole_excel.send(name, *args)
+        rescue NoMethodError
+          raise VBAMethodMissingError, "unknown VBA property or method #{name.inspect}"
+        end
       end
     end
   end