robust_excel_ole 0.5.1 → 0.6

data/lib/robust_excel_ole/bookstore.rb

@@ -28,11 +28,15 @@ module RobustExcelOle
       weakref_books = @filename2books[filename_key]
       return nil unless weakref_books
       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 (not wr_book.weakref_alive?)
+          trace "warn: this should never happen"
           begin 
             @filename2books[filename_key].delete(wr_book)
-          rescue
+          rescue 
+            trace "#{$!.message}"
             trace "Warning: deleting dead reference failed: file: #{filename.inspect}"
           end
         else

data/lib/robust_excel_ole/excel.rb

@@ -2,76 +2,89 @@
 
 require 'timeout'
 
+def ka 
+  Excel.kill_all
+end
+
+
 module RobustExcelOle      
 
   class Excel < REOCommon    
 
     attr_accessor :ole_excel
+    attr_accessor :visible
+    attr_accessor :displayalerts
 
     alias ole_object ole_excel
 
     @@hwnd2excel = {}    
 
     # creates a new Excel instance
+    # @param [Hash] options the options
+    # @option options [Variant] :displayalerts 
+    # @option options [Boolean] :visible 
     # @return [Excel] a new Excel instance
-    def self.create
-      new(:reuse => false)
+    def self.create(options = {})
+      new(options.merge({:reuse => false}))
     end
 
-    # returns (connects to) the current Excel instance, if such a running Excel instance exists    
-    #   more specific: connects to the first opened Excel instance
-    #   if this Excel instance is being closed, then Excel creates a new Excel instance that has the same Hwnd
-    # creates a new one, otherwise 
+    # returns (connects to) the current (first opened) Excel instance, if such a running Excel instance exists    
+    # returns a new Excel instance, otherwise
+    # @option options [Variant] :displayalerts 
+    # @option options [Boolean] :visible 
     # @return [Excel] an Excel instance
-    def self.current
-      new(:reuse => true)
+    def self.current(options = {})
+      new(options.merge({:reuse => true}))
     end
 
     # returns an Excel instance  
     # given a WIN32OLE object representing an Excel instance, or a Hash representing options
     # @param [Hash] options the options
-    # @option options [Boolean] :reuse  
-    # @option options [Boolean] :displayalerts 
-    # @option options [Boolean] :visible 
+    # @option options [Boolean] :reuse      
+    # @option options [Boolean] :visible
+    # @option options [Variant] :displayalerts  
     # options: 
     #  :reuse          connects to an already running Excel instance (true) or
-    #                  creates a new Excel instance (false)   (default: true)
-    #  :displayalerts  allows display alerts in Excel         (default: false)
-    #  :visible        makes the Excel visible                (default: false)
-    #  if :reuse => true, then DisplayAlerts and Visible are set only if they are given
+    #                  creates a new Excel instance (false)  (default: true)
+    #  :visible        makes the Excel visible               (default: false)
+    #  :displayalerts  enables or disables DisplayAlerts     (true, false, :if_visible (default))   
     # @return [Excel] an Excel instance
     def self.new(options = {})
       if options.is_a? WIN32OLE
-        excel = options
+        ole_xl = options
       else
         options = {:reuse => true}.merge(options)
         if options[:reuse] == true then
-          excel = current_excel
+          ole_xl = current_excel
         end
       end
-      if not (excel)
-        excel = WIN32OLE.new('Excel.Application')
+      #puts "options: #{options}"
+      if not (ole_xl)
+        ole_xl = WIN32OLE.new('Excel.Application')
         options = {
-          :displayalerts => false,
+          :displayalerts => :if_visible,
           :visible => false,
         }.merge(options)
       end
-      unless options.is_a? WIN32OLE
-        excel.DisplayAlerts = options[:displayalerts] unless options[:displayalerts].nil?
-        excel.Visible = options[:visible] unless options[:visible].nil?
-      end
-
-      hwnd = excel.HWnd
+      hwnd = ole_xl.HWnd
       stored = hwnd2excel(hwnd)
-
       if stored 
         result = stored
       else
         result = super(options)
-        result.instance_variable_set(:@ole_excel, excel)
-        WIN32OLE.const_load(excel, RobustExcelOle) unless RobustExcelOle.const_defined?(:CONSTANTS)
+        result.instance_variable_set(:@ole_excel, ole_xl)        
+        WIN32OLE.const_load(ole_xl, RobustExcelOle) unless RobustExcelOle.const_defined?(:CONSTANTS)
         @@hwnd2excel[hwnd] = WeakRef.new(result)
       end
+      unless options.is_a? WIN32OLE
+        reused = options[:reuse] && (not stored.nil?)
+        visible_value = (reused && options[:visible].nil?) ? result.visible : options[:visible]
+        displayalerts_value = (reused && options[:displayalerts].nil?) ? result.displayalerts : options[:displayalerts]
+        ole_xl.Visible = visible_value
+        ole_xl.DisplayAlerts = (displayalerts_value == :if_visible) ? visible_value : displayalerts_value
+        result.instance_variable_set(:@visible, visible_value)
+        result.instance_variable_set(:@displayalerts, displayalerts_value)
+      end
       result
     end
 
@@ -85,18 +98,17 @@ module RobustExcelOle
     # @option opts [Boolean] :displayalerts
     # @option opts [Boolean] :visible
     # options: reopen_workbooks (default: false): reopen the workbooks in the Excel instances
-    #          :visible (default: false), :displayalerts (default: false)
+    #          :visible (default: false), :displayalerts (default: :if_visible)
     # @return [Excel] an Excel instance
     def recreate(opts = {})      
       unless self.alive?
         opts = {
-          :displayalerts => @displayalerts ? @displayalerts : false,
-          :visible => @visible ? @visible : false
+          :visible => @visible ? @visible : false,
+          :displayalerts => @displayalerts ? @displayalerts : :if_visible          
         }.merge(opts)
-        new_excel = WIN32OLE.new('Excel.Application')
-        new_excel.DisplayAlerts = opts[:displayalerts]
-        new_excel.Visible = opts[:visible]
-        @ole_excel = new_excel 
+        @ole_excel = WIN32OLE.new('Excel.Application')
+        self.visible = opts[:visible]
+        self.displayalerts = opts[:displayalerts]        
         if opts[:reopen_workbooks]
           books = book_class.books
           books.each do |book|
@@ -109,9 +121,9 @@ module RobustExcelOle
 
   private
     
-    # returns (connects to) a running Excel instance
+    # returns a Win32OLE object that represents a Excel instance to which Excel connects
     # connects to the first opened Excel instance
-    # if this Excel instance is being closed, then Excel creates a new Excel instance that has the same Hwnd
+    # if this Excel instance is being closed, then Excel creates a new Excel instance
     def self.current_excel   # :nodoc: #
       result = WIN32OLE.connect('Excel.Application') rescue nil
       if result
@@ -127,9 +139,27 @@ module RobustExcelOle
 
   public
 
+    # closes the Excel
+    # @param [Hash] options the options
+    # @option options [Symbol] :if_unsaved :raise, :save, :forget, or :keep_open
+    # @option options [Boolean] :hard      
+    #  :if_unsaved    if unsaved workbooks are open in an Excel instance
+    #                      :raise (default) -> raises an exception       
+    #                      :save            -> saves the workbooks before closing
+    #                      :forget          -> closes the Excel instance without saving the workbooks 
+    #                      :keep_open       -> keeps the Excel instance open 
+    #  :hard          kill the Excel instance hard (default: false) 
+    def close(options = {})
+      options = {
+        :if_unsaved => :raise,
+        :hard => false
+      }.merge(options)      
+      close_excel(options) if managed_unsaved_workbooks(options)
+    end
+
     # closes all Excel instances
     # @param [Hash] options the options
-    # @option options [Symbol]  :if_unsaved :raise, :save, :forget, :alert, or :keep_open
+    # @option options [Symbol]  :if_unsaved :raise, :save, :forget, or :alert
     # @option options [Boolean] :hard
     # @option options [Boolean] :kill_if_timeout
     # options:
@@ -137,10 +167,9 @@ module RobustExcelOle
     #                      :raise (default) -> raises an exception       
     #                      :save            -> saves the workbooks before closing
     #                      :forget          -> closes the excel instance without saving the workbooks 
-    #                      :keep_open       -> let the workbooks open
     #                      :alert           -> give control to Excel
     #  :hard          closes Excel instances soft (default: false), or, additionally kills the Excel processes hard (true)
-    #  :kill_if_timeout:  kills Excel instances hard if the closing process exceeds a certain time limit (default: true)
+    #  :kill_if_timeout:  kills Excel instances hard if the closing process exceeds a certain time limit (default: false)
     # @raise ExcelError if time limit has exceeded, some Excel instance cannot be closed, or
     #                   unsaved workbooks exist and option :if_unsaved is :raise
     def self.close_all(options={})
@@ -148,21 +177,19 @@ module RobustExcelOle
         :if_unsaved => :raise,
         :hard => false,
         :kill_if_timeout => false
-      }.merge(options)      
-      excels_number = excel_processes.size
+      }.merge(options)           
       timeout = false
+      number = excels_number
       begin
-        status = Timeout::timeout(5) {
-          while current_excel do
-            close_one_excel(options)
-            GC.start
-            sleep 0.3
-            current_excels_number = excel_processes.size
-            if current_excels_number == excels_number && excels_number > 0
-              raise ExcelError, "some Excel instance cannot be closed"
+        status = Timeout::timeout(15) {
+          while (excels_number > 0) do
+            ole_xl = current_excel    
+            begin
+              (Excel.new(ole_xl).close(options); Excel.new(ole_xl).close(options)) if ole_xl  # two times necessary ?!
+            rescue RuntimeError => msg
+              raise msg unless msg.message =~ /failed to get Dispatch Interface/
             end
-            excels_number = current_excels_number
-          end   
+          end
         }
       rescue Timeout::Error
         raise ExcelError, "close_all: timeout" unless options[:kill_if_timeout]
@@ -170,18 +197,52 @@ module RobustExcelOle
       end
       kill_all if options[:hard] || (timeout && options[:kill_if_timeout])
       init
+      number
     end
 
-    def self.init
-      @@hwnd2excel = {}
+    def close_excel(options) # :nodoc:
+      ole_xl = @ole_excel
+      begin
+        if options[:if_unsaved] == :alert
+          with_displayalerts(true) {ole_xl.Workbooks.Close}
+        else
+          ole_xl.Workbooks.Close
+        end
+      rescue WIN32OLERuntimeError => msg
+        raise ExcelUserCanceled, "close: canceled by user" if msg.message =~ /80020009/ && 
+              options[:if_unsaved] == :alert && (not unsaved_workbooks.empty?)
+      end     
+      excel_hwnd = ole_xl.HWnd
+      ole_xl.Quit
+      weak_excel_ref = WeakRef.new(ole_xl)
+      ole_xl = @ole_excel = nil
+      GC.start
+      sleep 0.2
+      if weak_excel_ref.weakref_alive? then
+        begin
+          weak_excel_ref.ole_free
+          #trace "successfully ole_freed #{weak_excel_ref}"
+        rescue => msg
+          trace "#{msg.message}"
+          trace "could not do ole_free on #{weak_excel_ref}"
+        end
+      end
+      @@hwnd2excel.delete(excel_hwnd)      
+      if options[:hard] then
+        process_id = Win32API.new("user32", "GetWindowThreadProcessId", ["I","P"], "I")
+        pid_puffer = " " * 32
+        process_id.call(excel_hwnd, pid_puffer)
+        pid = pid_puffer.unpack("L")[0]
+        Process.kill("KILL", pid) rescue nil   
+      end
     end
 
   private
 
-    def self.manage_unsaved_workbooks(excel, options)     # :nodoc: #
-      unsaved_workbooks = []
+    def managed_unsaved_workbooks(options)   
+      unsaved_workbooks = []      
       begin
-        excel.Workbooks.each {|w| unsaved_workbooks << w unless (w.Saved || w.ReadOnly)}
+        @ole_excel.Workbooks.each {|w| unsaved_workbooks << w unless (w.Saved || w.ReadOnly)}
       rescue RuntimeError => msg
         trace "RuntimeError: #{msg.message}" 
         raise ExcelErrorOpen, "Excel instance not alive or damaged" if msg.message =~ /failed to get Dispatch Interface/
@@ -194,77 +255,30 @@ module RobustExcelOle
           unsaved_workbooks.each do |workbook|
             workbook.Save
           end
+          return true
         when :forget
           # nothing
-        when :keep_open
-          return
         when :alert
-          begin
-            excel.DisplayAlerts = true
-            yield
-          ensure
-            begin
-              excel.DisplayAlerts = false 
-            rescue RuntimeError => msg
-              trace "RuntimeError: #{msg.message}" if msg.message =~ /failed to get Dispatch Interface/
-            end
-          end
-          return
+          # nothing
+        when :keep_open
+          return false
         else
           raise ExcelErrorClose, ":if_unsaved: invalid option: #{options[:if_unsaved].inspect}"
         end
       end
-      yield
-    end
-
-    # closes one Excel instance to which one was connected
-    def self.close_one_excel(options={})
-      excel = current_excel
-      return unless excel
-      manage_unsaved_workbooks(excel, options) do
-        weak_ole_excel = WeakRef.new(excel)
-        excel = nil
-        close_excel_ole_instance(weak_ole_excel.__getobj__)
-      end
-    end
-
-    def self.close_excel_ole_instance(ole_excel)  # :nodoc: #
-      @@hwnd2excel.delete(ole_excel.Hwnd)
-      excel = ole_excel
-      ole_excel = nil
-      begin
-        excel.Workbooks.Close
-        excel_hwnd = excel.HWnd
-        excel.Quit
-        weak_excel_ref = WeakRef.new(excel)
-        excel = nil
-        GC.start
-        sleep 0.2
-        if weak_excel_ref.weakref_alive? then
-          begin
-            weak_excel_ref.ole_free
-            trace "successfully ole_freed #{weak_excel_ref}"
-          rescue
-            trace "could not do ole_free on #{weak_excel_ref}"
-          end
-        end
-        @@hwnd2excel.delete(excel_hwnd)
-      rescue => e
-        trace "Error when closing Excel: #{e.message}"
-        #t e.backtrace
-      end
-      free_all_ole_objects
+      return true
     end
 
     # frees all OLE objects in the object space
     def self.free_all_ole_objects     # :nodoc: #
       anz_objekte = 0
-      ObjectSpace.each_object(WIN32OLE) do |o|
+      ObjectSpace.each_object(WIN32OLE) do |o|        
         anz_objekte += 1
-        #t [:Name, (o.Name rescue (o.Count rescue "no_name"))]
-        #t [:ole_object_name, (o.ole_object_name rescue nil)]
-        #t [:methods, (o.ole_methods rescue nil)] unless (o.Name rescue false)
-        #t o.ole_type rescue nil
+        #trace "#{anz_objekte} name: #{(o.Name rescue (o.Count rescue "no_name"))} ole_object_name: #{(o.ole_object_name rescue nil)} type: #{o.ole_type rescue nil}"
+        #trace [:Name, (o.Name rescue (o.Count rescue "no_name"))]
+        #trace [:ole_object_name, (o.ole_object_name rescue nil)]
+        #trace [:methods, (o.ole_methods rescue nil)] unless (o.Name rescue false)
+        #trace o.ole_type rescue nil
         begin
           o.ole_free
           #trace "olefree OK"
@@ -276,62 +290,10 @@ module RobustExcelOle
       trace "went through #{anz_objekte} OLE objects"
     end   
 
-  public
 
-    # closes the Excel
-    # @param [Hash] options the options
-    # @option options [Symbol] :if_unsaved :raise, :save, :forget, or :keep_open
-    # @option options [Boolean] :hard      
-    #  :if_unsaved    if unsaved workbooks are open in an Excel instance
-    #                      :raise (default) -> raises an exception       
-    #                      :save            -> saves the workbooks before closing
-    #                      :forget          -> closes the Excel instance without saving the workbooks 
-    #                      :keep_open       -> keeps the Excel instance open 
-    #  :hard          kill the Excel instance hard (default: false) 
-    def close(options = {})
-      options = {
-        :if_unsaved => :raise,
-        :hard => false
-      }.merge(options)
-      self.class.manage_unsaved_workbooks(@ole_excel, options) do 
-        close_excel(options)
-      end
-    end
-
-  private
-
-    def close_excel(options)
-      excel = @ole_excel
-      begin
-        excel.Workbooks.Close
-      rescue WIN32OLERuntimeError => msg
-        raise ExcelUserCanceled, "close: canceled by user" if msg.message =~ /80020009/ && 
-              options[:if_unsaved] == :alert && (not self.unsaved_workbooks.empty?)
-      end
-      excel_hwnd = excel.HWnd
-      excel.Quit
-      weak_excel_ref = WeakRef.new(excel)
-      excel = nil
-      GC.start
-      sleep 0.2
-      if weak_excel_ref.weakref_alive? then
-        begin
-          weak_excel_ref.ole_free
-          trace "successfully ole_freed #{weak_excel_ref}"
-        rescue => msg
-          trace "#{msg.message}"
-          trace "could not do ole_free on #{weak_excel_ref}"
-        end
-      end
-      @@hwnd2excel.delete(excel_hwnd)      
-      if options[:hard] then
-        process_id = Win32API.new("user32", "GetWindowThreadProcessId", ["I","P"], "I")
-        pid_puffer = " " * 32
-        process_id.call(excel_hwnd, pid_puffer)
-        pid = pid_puffer.unpack("L")[0]
-        Process.kill("KILL", pid) rescue nil   
-      end
-    end
+    def self.init
+      @@hwnd2excel = {}
+    end    
 
   public
 
@@ -342,12 +304,21 @@ module RobustExcelOle
       processes = procs.InstancesOf("win32_process")
       number = processes.select{|p| (p.name == "EXCEL.EXE")}.size
       procs.InstancesOf("win32_process").each do |p|
-        Process.kill('KILL', p.processid) if p.name == "EXCEL.EXE"        
+        begin
+          Process.kill('KILL', p.processid) if p.name == "EXCEL.EXE"        
+        rescue 
+           trace "kill error: #{$!}"
+        end
       end
       init
       number
     end
 
+    def self.excels_number
+      WIN32OLE.connect("winmgmts:\\\\.").InstancesOf("win32_process").select{|p| (p.name == "EXCEL.EXE")}.size
+    end
+
+=begin
     # provide Excel objects 
     # (so far restricted to all Excel instances opened with RobustExcelOle,
     #  not for Excel instances opened by the user)
@@ -376,6 +347,7 @@ module RobustExcelOle
       end
       result
     end
+=end    
 
     def excel   # :nodoc: #
       self
@@ -419,7 +391,7 @@ module RobustExcelOle
       @ole_excel.Name
       true
     rescue
-      #t $!.message
+      #trace $!.message
       false
     end
 
@@ -472,34 +444,39 @@ module RobustExcelOle
 
     # sets DisplayAlerts in a block
     def with_displayalerts displayalerts_value
-      old_displayalerts = @ole_excel.DisplayAlerts
-      @ole_excel.DisplayAlerts = displayalerts_value
+      old_displayalerts = self.displayalerts
+      self.displayalerts = displayalerts_value
       begin
          yield self
       ensure
-        @ole_excel.DisplayAlerts = old_displayalerts if alive?
+        self.displayalerts = old_displayalerts if alive?
       end
     end    
 
     # enables DisplayAlerts in the current Excel instance
     def displayalerts= displayalerts_value
-      @displayalerts = @ole_excel.DisplayAlerts = displayalerts_value
-    end
-
-    # return whether DisplayAlerts is enabled in the current Excel instance
-    def displayalerts 
-      @displayalerts = @ole_excel.DisplayAlerts
+      @displayalerts = displayalerts_value
+      @ole_excel.DisplayAlerts = (@displayalerts == :if_visible) ? @ole_excel.Visible : displayalerts_value
     end
 
     # makes the current Excel instance visible or invisible
     def visible= visible_value
-      @visible = @ole_excel.Visible = visible_value
-    end
+      @ole_excel.Visible = @visible = visible_value
+      @ole_excel.DisplayAlerts = @visible if @displayalerts == :if_visible
+    end   
 
-    # returns whether the current Excel instance is visible
-    def visible 
-      @visible = @ole_excel.Visible
-    end    
+    # make all workbooks visible or invisible
+    def workbooks_visible= visible_value
+      begin
+        @ole_excel.Workbooks.each do |ole_wb| 
+          workbook = Book.new(ole_wb)
+          workbook.visible = visible_value
+        end
+      rescue RuntimeError => msg
+        trace "RuntimeError: #{msg.message}" 
+        raise ExcelErrorOpen, "Excel instance not alive or damaged" if msg.message =~ /failed to get Dispatch Interface/
+      end
+    end
 
     # sets calculation mode in a block
     def with_calculation(calculation_mode = :automatic)