robust_excel_ole 0.6.2 → 1.0

data/lib/robust_excel_ole/book.rb

@@ -180,7 +180,8 @@ module RobustExcelOle
 
   public
 
-    def self.open_in_current_excel(file, opts = { })
+    # work in progress#
+    def self.open_in_current_excel(file, opts = { }) # :nodoc: # 
       options = DEFAULT_OPEN_OPTS.merge(opts)
       filename = General::absolute_path(file)
       ole_workbook = WIN32OLE.connect(filename)
@@ -325,7 +326,7 @@ module RobustExcelOle
         rescue WIN32OLERuntimeError => msg
           # trace "WIN32OLERuntimeError: #{msg.message}" 
           if msg.message =~ /800A03EC/
-            raise WorkbookError, "open: user canceled or open error"
+            raise ExcelError, "user canceled or runtime error"
           else 
             raise UnexpectedError, "unknown WIN32OLERuntimeError"
           end

data/lib/robust_excel_ole/excel.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 
-require 'timeout'
+require 'weakref'
 
 def ka 
   Excel.kill_all
@@ -62,11 +62,13 @@ module RobustExcelOle
 
       hwnd = ole_xl.HWnd
       stored = hwnd2excel(hwnd)
-      if stored 
+      if stored and stored.alive?
         result = stored
       else 
-        options[:visible] = options[:visible].nil? ? ole_xl.Visible : options[:visible]
-        options[:displayalerts] = options[:displayalerts].nil? ? :if_visible : options[:displayalerts]
+        unless options.is_a? WIN32OLE
+          options[:visible] = options[:visible].nil? ? ole_xl.Visible : options[:visible]
+          options[:displayalerts] = options[:displayalerts].nil? ? :if_visible : options[:displayalerts]
+        end
         result = super(options)
         result.instance_variable_set(:@ole_excel, ole_xl)        
         WIN32OLE.const_load(ole_xl, RobustExcelOle) unless RobustExcelOle.const_defined?(:CONSTANTS)
@@ -142,142 +144,172 @@ 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      
+    def self.contains_unsaved_workbooks?
+      excel = begin
+        Excel.current
+      rescue
+        return false
+      end
+      not excel.unsaved_workbooks.empty?
+    end
+
+    # returns unsaved workbooks
+    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
+    end
+
+    # closes workbooks
+    # @option options [Symbol] :if_unsaved :raise, :save, :forget, :alert, Proc
     #  :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 Excel instances opened via RobustExcelOle
-    # @return [Fixnum] number of closed Excel instances
+    #                      :alert           -> let Excel do it
+    def close_workbooks(options = {:if_unsaved => :raise})
+      return if not self.alive?
+      weak_wkbks = @ole_excel.Workbooks
+      if not unsaved_workbooks.empty? then
+        case options[:if_unsaved]
+        when Proc then
+          options[:if_unsaved].call(self, unsaved_workbooks)
+        when :raise then
+          raise UnsavedWorkbooks, "Excel contains unsaved workbooks"
+        when :alert then
+          #nothing
+        when :forget then
+          unsaved_workbooks.each {|m| m.Saved = true}
+        when :save then
+          unsaved_workbooks.each {|m| m.Save}
+        else
+          raise OptionInvalid, ":if_unsaved: invalid option: #{options[:if_unsaved].inspect}"
+        end
+      end
+      begin
+        @ole_excel.Workbooks.Close
+      rescue WIN32OLERuntimeError => msg
+        # trace "WIN32OLERuntimeError: #{msg.message}" 
+        if msg.message =~ /800A03EC/
+          raise ExcelError, "user canceled or runtime error"
+        else 
+          raise UnexpectedError, "unknown WIN32OLERuntimeError"
+        end
+      end   
+      weak_wkbks = nil
+      weak_wkbks = @ole_excel.Workbooks
+      weak_wkbks = nil
+     end
+
+    # closes all Excel instances
+    # @return [Fixnum,Fixnum] number of closed Excel instances, number of errors
     # @param [Hash] options the options
     # @option options [Symbol]  :if_unsaved :raise, :save, :forget, or :alert
-    # @option options [Boolean] :hard
-    # @option options [Boolean] :kill_if_timeout
     # options:
     #  :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 
     #                      :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: false)
-    def self.close_all(options={})
-      options = {
-        :if_unsaved => :raise,
-        :hard => false,
-        :kill_if_timeout => false
-      }.merge(options)           
-      timeout = false
-      number = @@hwnd2excel.size
-      unsaved_workbooks = false
-      begin
-        status = Timeout::timeout(60) {
-          @@hwnd2excel.each do |hwnd, wr_excel|
-            excel = wr_excel.__getobj__
-            begin
-              excel.close(options)
-            rescue UnsavedWorkbooks
-              unsaved_workbooks = true
-            end
-            sleep 0.2
+    # @option options [Proc] block
+    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
+      finishing_action = proc do |excel|
+        if excel
+          begin
+            overall_number += 1
+            finished_number += excel.close(:if_unsaved => options[:if_unsaved])
+          rescue
+            first_error = $!
+            #trace "error when finishing #{$!}"
+            error_number += 1
           end
-          raise UnsavedWorkbooks, "Excel contains unsaved workbooks" if unsaved_workbooks
-          free_all_ole_objects if excels_number > 0 #&& (not unsaved_workbooks)
-          # close also interactively opened Excels, but for unsaved workbooks: hangs as soon sending a VBA method
-          #while (n = excels_number) > 0 do
-          #  ole_xl = current_excel    
-          #  begin
-          #    Excel.new(ole_xl).close(options) if ole_xl 
-          #  rescue RuntimeError => msg
-          #    raise msg unless msg.message =~ /failed to get Dispatch Interface/
-          #  end
-          #end
-        }
-      rescue Timeout::Error
-        raise TimeOut, "close_all: timeout" unless options[:kill_if_timeout]
-        timeout = true
-      end
-      kill_all if options[:hard] || (timeout && options[:kill_if_timeout])
-      init
-      number
-    end
+        end
+      end
 
-    def close_excel(options) # :nodoc:
-      ole_xl = @ole_excel
-      begin
-        with_displayalerts(options[:if_unsaved] == :alert) { ole_xl.Workbooks.Close }
-      rescue WIN32OLERuntimeError => msg
-        trace "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}"
+      # known Excel-instances
+      @@hwnd2excel.each do |hwnd, wr_excel|
+        if wr_excel.weakref_alive?
+          excel = wr_excel.__getobj__
+          if excel.alive?
+            excel.displayalerts = false
+            finishing_action.call(excel)
+          end
+        else
+          @@hwnd2excel.delete(hwnd) 
         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   
+
+      # unknown Excel-instances
+      old_error_number = error_number
+      9.times do |index|
+        sleep 0.1
+        excel = new(WIN32OLE.connect('Excel.Application')) rescue nil
+        finishing_action.call(excel) if excel
+        free_all_ole_objects unless error_number > 0 and options[:if_unsaved] == :raise 
+        break if not excel
+        break if error_number > old_error_number # + 3        
       end
-    end
 
-  private
+      raise first_error if (options[:if_unsaved] == :raise and first_error) or first_error.class == OptionInvalid
 
-    def managed_unsaved_workbooks(options)   
-      unsaved_workbooks = []      
-      begin
-        @ole_excel.Workbooks.each {|w| unsaved_workbooks << w unless (w.Saved || w.ReadOnly)}
-      rescue RuntimeError => msg
-        trace "RuntimeError: #{msg.message}" 
-        raise ExcelDamaged, "Excel instance not alive or damaged" if msg.message =~ /failed to get Dispatch Interface/
-      end
-      unless unsaved_workbooks.empty? 
-        case options[:if_unsaved]
-        when :raise
-          raise UnsavedWorkbooks, "Excel contains unsaved workbooks"
-        when :save
-          unsaved_workbooks.each do |workbook|
-            workbook.Save
+      [finished_number, error_number]
+    end
+
+    # closes the Excel
+    # @param [Hash] options the options
+    # @option options [Symbol] :if_unsaved :raise, :save, :forget, :alert
+    # @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 
+    #                      :alert           -> Excel takes over 
+    def close(options = {:if_unsaved => :raise})
+      finishing_living_excel = self.alive?
+      if finishing_living_excel then
+        hwnd = (@ole_excel.HWnd rescue nil)
+        close_workbooks(:if_unsaved => options[:if_unsaved])
+        @ole_excel.Quit
+        if false and defined?(weak_wkbks)  and weak_wkbks.weakref_alive? then
+          weak_wkbks.ole_free
+        end
+        weak_xl = WeakRef.new(@ole_excel)
+      else
+        weak_xl = nil
+      end 
+      @ole_excel = nil
+      GC.start
+      sleep 0.1
+      if finishing_living_excel then
+        if hwnd then          
+          process_id = Win32API.new("user32", "GetWindowThreadProcessId", ["I","P"], "I")
+          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
+        end
+        @@hwnd2excel.delete(hwnd)
+        if weak_xl.weakref_alive? then
+           #if WIN32OLE.ole_reference_count(weak_xlapp) > 0
+          begin
+            weak_xl.ole_free
+          rescue
+            #trace "weakref_probl_olefree"
           end
-          return true
-        when :forget
-          # nothing
-        when :alert
-          # nothing
-        when :keep_open
-          return false
-        else
-          raise OptionInvalid, ":if_unsaved: invalid option: #{options[:if_unsaved].inspect}"
         end
       end
-      return true
+      weak_xl ? 1 : 0
     end
 
     # frees all OLE objects in the object space
@@ -306,8 +338,6 @@ module RobustExcelOle
       @@hwnd2excel = {}
     end    
 
-  public
-
     # kill all Excel instances
     # @return [Fixnum] number of killed Excel processes
     def self.kill_all
@@ -318,7 +348,7 @@ module RobustExcelOle
         begin
           Process.kill('KILL', p.processid) if p.name == "EXCEL.EXE"        
         rescue 
-           trace "kill error: #{$!}"
+           #trace "kill error: #{$!}"
         end
       end
       init
@@ -335,12 +365,14 @@ module RobustExcelOle
     def self.excel_processes
       pid2excel = {}
       @@hwnd2excel.each do |hwnd,wr_excel|
-        excel = wr_excel.__getobj__
-        process_id = Win32API.new("user32", "GetWindowThreadProcessId", ["I","P"], "I")
-        pid_puffer = " " * 32
-        process_id.call(hwnd, pid_puffer)
-        pid = pid_puffer.unpack("L")[0]
-        pid2excel[pid] = excel
+        if wr_excel.weakref_alive?
+          excel = wr_excel.__getobj__
+          process_id = Win32API.new("user32", "GetWindowThreadProcessId", ["I","P"], "I")
+          pid_puffer = " " * 32
+          process_id.call(hwnd, pid_puffer)
+          pid = pid_puffer.unpack("L")[0]
+          pid2excel[pid] = excel
+        end
       end
       procs = WIN32OLE.connect("winmgmts:\\\\.")
       processes = procs.InstancesOf("win32_process")     
@@ -405,28 +437,16 @@ module RobustExcelOle
     end
 
     
-    # returns all unsaved workbooks in Excel instances
-    def self.unsaved_workbooks_all    # :nodoc: #
+    # returns unsaved workbooks in known (not opened by user) Excel instances
+    def self.unsaved_known_workbooks    
       result = []
       @@hwnd2excel.each do |hwnd,wr_excel| 
-        excel = wr_excel.__getobj__
+        excel = wr_excel.__getobj__ if wr_excel.weakref_alive?
         result << excel.unsaved_workbooks
       end
       result
     end
 
-    # returns unsaved workbooks
-    def unsaved_workbooks
-      result = []
-      begin
-        self.Workbooks.each {|w| result << w unless (w.Saved || w.ReadOnly)}
-      rescue RuntimeError => msg
-        trace "RuntimeError: #{msg.message}" 
-        raise ExcelDamaged, "Excel instance not alive or damaged" if msg.message =~ /failed to get Dispatch Interface/
-      end
-      result      
-    end
-
     def print_workbooks
       self.Workbooks.each {|w| trace "#{w.Name} #{w}"}
     end

data/lib/robust_excel_ole/reo_common.rb

@@ -1,5 +1,5 @@
-LOG_TO_STDOUT = true      unless Object.const_defined?(:LOG_TO_STDOUT)
-REO_LOG_DIR   = ""        unless Object.const_defined?(:REO_LOG_DIR)
+LOG_TO_STDOUT = false     unless Object.const_defined?(:LOG_TO_STDOUT)
+REO_LOG_DIR   = "" unless Object.const_defined?(:REO_LOG_DIR)
 REO_LOG_FILE  = "reo.log" unless Object.const_defined?(:REO_LOG_FILE)
   
 File.delete REO_LOG_FILE rescue nil

data/lib/robust_excel_ole/version.rb

@@ -1,3 +1,3 @@
 module RobustExcelOle
-  VERSION = "0.6.2"
+  VERSION = "1.0"
 end

data/robust_excel_ole.gemspec

@@ -8,9 +8,14 @@ Gem::Specification.new do |s|
   s.authors     = ["traths"]
   s.email       = ["Thomas.Raths@gmx.net"]
   s.homepage    = "https://github.com/Thomas008/robust_excel_ole"
-  s.summary     = "RobustExcelOle processes Excel files and wraps the win32ole library."
-  s.description = "RobustExcelOle processes Excel files, provides all win32ole operations, convenient methods for opening, saving and closing, and implements an Excel file management system."
+  
+  s.summary     = "RobustExcelOle automates processing Excel files in Windows by using the win32ole library."
+  s.description = "RobustExcelOle automates modifying, reading and writing Excel files.
+                   It supports simultaneously running Excel instances and user interactions.
+                   RobustExcelOle deals with various cases of Excel (and user) behaviour,
+                   supplies workarounds for some Excel bugs, and supports referenced libraries"                 
 
+  s. licenses = ['MIT']
   s.rubyforge_project = "robust_excel_ole"
 
   s.files         = `git ls-files`.split("\n")

data/spec/book_spec.rb

@@ -316,7 +316,7 @@ describe Book do
           @key_sender.puts "{right}{enter}"
           expect{
             Book.open(@simple_file, :if_unsaved => :alert)
-            }.to raise_error(WorkbookError, "open: user canceled or open error")
+            }.to raise_error(ExcelError, "user canceled or runtime error")
           @book.should be_alive
         end
 
@@ -338,7 +338,7 @@ describe Book do
           @key_sender.puts "{right}{enter}"
           expect{
             Book.open(@simple_file, :if_unsaved => :excel)
-            }.to raise_error(WorkbookError, "open: user canceled or open error")
+            }.to raise_error(ExcelError, "user canceled or runtime error")
           @book.should be_alive
         end