robust_excel_ole 1.13 → 1.14

data/docs/README_save_close.rdoc

@@ -6,17 +6,17 @@
 
 Imagine, you have opened a workbook with
 
-  book = Workbook.open('spec/data/workbook.xls', :visible => true)
+  workbook = Workbook.open('spec/data/workbook.xls', :visible => true)
 
 and have modified it.
 
 You can save the workbook by
 
-  book.save
+  workbook.save
 
 If you want to save a workbook with a file name, then use
 
-  book.save_as('new_workbook.xls')
+  workbook.save_as('new_workbook.xls')
 
 The options and respective valid values are the following:
 
@@ -33,19 +33,19 @@ If a workbook with the file name already exists, then
   
 For example, you want to save a workbook and overwrite the file if it exists before, then use
 
-  book.save_as('another_workbook.xls', :if_exists => :overwrite) 
+  workbook.save_as('another_workbook.xls', :if_exists => :overwrite) 
 
 If a workbook blocks the workbook that should be saved, then the former one can be saved and closed before.
 
-  book = Workbook.open('spec/data/workbook.xls')
-  book2 = Workbook.open('spec/data/another_workbook.xls')
-  book2.save_as('dir/workbook.xls', :if_exists => :overwrite, :if_obstructed => :save)  
+  workbook = Workbook.open('spec/data/workbook.xls')
+  workbook2 = Workbook.open('spec/data/another_workbook.xls')
+  workbook2.save_as('dir/workbook.xls', :if_exists => :overwrite, :if_obstructed => :save)  
 
 === Closing a workbook.
 
 You can close the workbook with the command
 
-  book.close
+  workbook.close
 
 There is one option: +:if_unsaved+ . It can have one of the following values:
 
@@ -62,7 +62,7 @@ The option specifies: If the workbook is unsaved, then
 
 You can open a workbook with given file name.
 
-  book = Workbook.open('spec/data/workbook.xls')
+  workbook = Workbook.open('spec/data/workbook.xls')
 
 You can save a workbook with given file name, if it is open.
 

data/docs/README_sheet.rdoc

@@ -6,30 +6,30 @@ Worksheets are represented by Worksheet objects.
 
 Assume you have opened a workbook
 
-  book = Workbook.open('spec/data/workbook.xls', :visible => true)
+  workbook = Workbook.open('spec/data/workbook.xls', :visible => true)
 
 === Accessing a worksheet.
 
 You can access a worksheet by giving the number
 
-  sheet = book.sheet(1)
+  worksheet = book.sheet(1)
 
 or its name
 
-  sheet = book.sheet('Sheet1')
+  worksheet = book.sheet('Sheet1')
 
 You can get the first and last worksheet with
 
-  sheet = book.first_sheet  
+  worksheet = book.first_sheet  
 
 and
 
-  sheet = book.last_sheet  
+  worksheet = book.last_sheet  
 
-You can access all Sheet objects by using the methods Workbook#each.
+You can access all Worksheet objects by using the methods Workbook#each.
 
-  book.each do |sheet|               
-    # do something with sheet
+  workbook.each do |worksheet|               
+    # do something with worksheet
   end
 
 Once you have got a Sheet object (in RobustExcelOle), you can apply all VBA methods that you would apply to a VBA Worksheet object
@@ -40,38 +40,38 @@ For some common and complex tasks you can apply methods of RobustExcelOle.
 
 You can read and change the worksheet name.
 
-  sheet1.name
+  worksheet1.name
   # => "Sheet1"
 
-  sheet1.name = "new_sheet"
+  worksheet1.name = "new_sheet"
 
 === Adding and copying a worksheet.
 
 You can add (append) an empty worksheet using
 
-  book.add_empty_sheet
+  workbook.add_empty_sheet
 
 Additionally you can name it.
 
-  book.add_empty_sheet(:as => 'sheet_name')
+  workbook.add_empty_sheet(:as => 'sheet_name')
 
 You can specify the position of the added empty worksheet.
 
-  book.add_empty_sheet(:as => 'new_name', :before => another_sheet)
+  workbook.add_empty_sheet(:as => 'new_name', :before => another_sheet)
 
 You can copy a worksheet and add it.
 
-  book.copy_sheet sheet
+  workbook.copy_sheet sheet
 
 Additionally you can specify a name and a position.
 
-  book.copy_sheet(sheet, :as => 'new_name', :after => another_sheet)
+  workbook.copy_sheet(sheet, :as => 'new_name', :after => another_sheet)
 
 If you want to copy a worksheet, if a worksheet +sheet+ is given, and add an empty worksheet, if no worksheet is given, then use
 
-  book.add_or_copy_sheet
+  workbook.add_or_copy_sheet
 
-  book.add_or_copy_sheet(sheet, :as => 'new_name', :after => another_sheet)  
+  workbook.add_or_copy_sheet(sheet, :as => 'new_name', :after => another_sheet)  
 
 Note, that running in jruby, due to some restrictions of jruby, there is a workaround when adding or copy a worksheet at the end (appending): the last worksheet is being copied and deleted afterwards, in order to serve as a dummy worksheet. This may cause a different behaviour.
 

data/lib/robust_excel_ole.rb

@@ -14,5 +14,7 @@ require File.join(File.dirname(__FILE__), 'robust_excel_ole/worksheet')
 require File.join(File.dirname(__FILE__), 'robust_excel_ole/cell')
 require File.join(File.dirname(__FILE__), 'robust_excel_ole/range')
 require File.join(File.dirname(__FILE__), 'robust_excel_ole/cygwin') if RUBY_PLATFORM =~ /cygwin/
-#+#require "robust_excel_ole/version"
 require File.join(File.dirname(__FILE__), 'robust_excel_ole/version')
+
+include RobustExcelOle
+include General

data/lib/robust_excel_ole/excel.rb

@@ -76,12 +76,7 @@ module RobustExcelOle
       ole_xl = win32ole_excel unless win32ole_excel.nil?
       options = { :reuse => true }.merge(options)
       if options[:reuse] == true && ole_xl.nil?
-        ole_xl = if JRUBY_BUG_CONNECTEXCEL
-          excel_instance = known_excel_instance 
-          excel_instance.ole_excel unless excel_instance.nil?
-        else
-          current_excel
-        end
+        ole_xl = current_ole_excel
       end
       connected = (not ole_xl.nil?) && win32ole_excel.nil?
       ole_xl ||= WIN32OLE.new('Excel.Application')
@@ -142,33 +137,6 @@ module RobustExcelOle
 
   private
 
-    # 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
-    # @private
-    def self.current_excel      
-      result = if result.nil?
-        begin
-          WIN32OLE.connect('Excel.Application')
-        rescue
-          nil
-        end
-      end
-      if result
-        begin
-          result.Visible # send any method, just to see if it responds
-        rescue
-          trace 'dead excel ' + (begin
-                                   "Window-handle = #{result.HWnd}"
-                                 rescue
-                                   'without window handle'
-                                 end)
-          return nil
-        end
-      end
-      result
-    end
-
     # retain the saved status of all workbooks
     # @private
     def retain_saved_workbooks
@@ -424,6 +392,43 @@ module RobustExcelOle
       @@hwnd2excel.size
     end
 
+  #private
+
+    # 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
+    # @private
+    def self.current_ole_excel   
+      if JRUBY_BUG_CONNECT
+        result = known_excel_instance
+        if result.nil?
+          if excels_number > 0
+            dummy_ole_workbook = WIN32OLE.connect(General.absolute_path('___dummy_workbook.xls')) rescue nil
+            result = dummy_ole_workbook.Application
+            visible_status = result.Visible
+            dummy_ole_workbook.Close
+            dummy_ole_workbook = nil
+            result.Visible = visible_status
+          end
+        end
+      else
+        result = WIN32OLE.connect('Excel.Application') rescue nil
+      end
+      if result
+        begin
+          result.Visible # send any method, just to see if it responds
+        rescue
+          trace 'dead excel ' + (begin
+                                 "Window-handle = #{result.HWnd}"
+                                 rescue
+                                 'without window handle'
+                                 end)
+          return nil
+        end
+      end
+      result
+    end
+
     # returns an Excel instance
     def self.known_excel_instance
       @@hwnd2excel.each do |hwnd, wr_excel|

data/lib/robust_excel_ole/reo_common.rb

@@ -173,8 +173,7 @@ module RobustExcelOle
           home = homes.find { |h| !ENV[h].nil? }
           reo_log_dir = ENV[home]
         else
-          #reo_log_dir = REO_LOG_DIR
-          reo_log_dir = "C:/Users/User"
+          reo_log_dir = REO_LOG_DIR
         end
         File.open(reo_log_dir + '/' + REO_LOG_FILE,'a') do |file|
           file.puts text

data/lib/robust_excel_ole/version.rb

@@ -1,3 +1,3 @@
 module RobustExcelOle
-  VERSION = "1.13"
+  VERSION = "1.14"
 end

data/lib/robust_excel_ole/workbook.rb

@@ -11,10 +11,13 @@ module RobustExcelOle
 
   class Workbook < RangeOwners
 
+    #include General 
+
     attr_accessor :excel
     attr_accessor :ole_workbook
     attr_accessor :stored_filename
     attr_accessor :color_if_modified
+    attr_accessor :was_open
     attr_reader :workbook
 
     alias ole_object ole_workbook
@@ -39,7 +42,7 @@ module RobustExcelOle
 
 
     # opens a workbook.
-    # @param [String] file the file name
+    # @param [String] file_or_workbook a file name or WIN32OLE workbook
     # @param [Hash] opts the options
     # @option opts [Hash] :default or :d
     # @option opts [Hash] :force or :f
@@ -106,7 +109,8 @@ module RobustExcelOle
         rescue
           trace "#{$!.message}"
         end
-        if book      
+        if book 
+          book.was_open = book.alive?
           # drop the fetched workbook if it shall be opened in another Excel instance
           # or the workbook is an unsaved workbook that should not be accepted
           if (options[:force][:excel].nil? || options[:force][:excel] == :current || forced_excel == book.excel) &&
@@ -226,51 +230,33 @@ module RobustExcelOle
       raise ExcelREOError, "excel is not alive" unless @excel && @excel.alive?
     end
 
-    # @private
-    # restriction for jruby: does not manage conflicts with blocking or unsaved workbooks
+    # @private    
     def ensure_workbook(filename, options)  
-      if options[:if_unsaved]==:accept && 
-        ((options[:read_only]==true && self.ReadOnly==false) || (options[:read_only]==false && self.ReadOnly==true))
-        raise OptionInvalid, ":if_unsaved:accept and change of read-only mode is not possible"
-      end
       unless @ole_workbook && alive?
         filename = @stored_filename ? @stored_filename : filename 
         manage_nonexisting_file(filename,options)
         excel_option = options[:force][:excel].nil? ? options[:default][:excel] : options[:force][:excel]        
-        if JRUBY_BUG_CONNECT
-          (excel_option.nil? || excel_option == :current) && filename[0] != '/'
-          begin
+        ensure_excel(options)
+        workbooks = @excel.Workbooks
+        @ole_workbook = workbooks.Item(File.basename(filename)) rescue nil if @ole_workbook.nil?
+        if @ole_workbook
+          @was_open = true
+          manage_blocking_or_unsaved_workbook(filename,options)
+        else
+          if excel_option.nil? || excel_option == :current &&  
+            (!JRUBY_BUG_CONNECT || filename[0] != '/')
             connect(filename,options)
-          rescue WorkbookConnectingUnsavedError
-            raise WorkbookNotSaved, "workbook is already open but not saved: #{File.basename(filename).inspect}"
-          rescue WorkbookConnectingBlockingError
-            raise WorkbookBlocked, "can't open workbook #{filename}"+
-              "\nbecause it is being blocked by a workbook with the same name in a different path."
-          rescue WorkbookConnectingUnknownError
-            raise WorkbookREOError, "can't connect to workbook #{filename}"
+          else 
+            open_or_create_workbook(filename,options)
           end
-          manage_unsaved_workbook(filename,options) unless @ole_workbook.Saved
-        else
-          ensure_excel(options)
-          workbooks = @excel.Workbooks
-          @ole_workbook = workbooks.Item(File.basename(filename)) rescue nil if @ole_workbook.nil?
-          if @ole_workbook
-            manage_blocking_or_unsaved_workbook(filename,options)
-          else
-            if excel_option.nil? || excel_option == :current &&             
-              (!JRUBY_BUG_CONNECT || filename[0] != '/')
-              connect(filename,options)
-            else 
-              open_or_create_workbook(filename,options)
-            end
-          end       
-        end
+        end       
       end
     end
 
     # @private
     def set_options(filename, options)
       if (!options[:read_only].nil?) && options[:read_only] != @ole_workbook.ReadOnly
+        #raise OptionInvalid, ":if_unsaved:accept and changing read-only mode is not possible" if options[:if_unsaved]==:accept
         @excel.with_displayalerts(false) { @ole_workbook.Close }
         @ole_workbook = nil        
         open_or_create_workbook(filename, options)
@@ -282,11 +268,17 @@ module RobustExcelOle
       end
     end
 
+
   private
 
     # @private
-    # connects to an unknown workbook and returns true, if it exists
+    # connects to an unknown workbook
     def connect(filename,options)
+      excels_number = excel_class.excels_number
+      workbooks_number = if excels_number>0 
+        excel_class.current.Workbooks.Count 
+      else 0
+      end
       abs_filename = General.absolute_path(filename)
       @ole_workbook = begin
         WIN32OLE.connect(abs_filename)
@@ -307,10 +299,13 @@ module RobustExcelOle
         end
       end
       @excel = excel_class.new(ole_excel)
+      excels_number_after = excel_class.excels_number
+      workbooks_number_after = ole_excel.Workbooks.Count
+      @was_open = (excels_number_after==excels_number) && (workbooks_number_after==workbooks_number)      
     end
 
     # @private
-    def manage_nonexisting_file(filename,options)      
+    def manage_nonexisting_file(filename,options)   
       return if File.exist?(filename)
       abs_filename = General.absolute_path(filename)
       if options[:if_absent] == :create
@@ -566,75 +561,107 @@ module RobustExcelOle
       unobtrusively(*args, &block)
     end
 
-
     # allows to read or modify a workbook such that its state remains unchanged
     # state comprises: open, saved, writable, visible, calculation mode, check compatibility
-    # @param [String] file        the file name
+    # @param [String] file_or_workbook     a file name or WIN32OLE workbook
     # @param [Hash]   opts        the options
     # @option opts [Variant] :if_closed  :current (default), :new or an Excel instance
-    # @option opts [Boolean] :read_only true/false, open the workbook in read-only/read-write modus (save changes)
-    # @option opts [Boolean] :writable  true/false changes of the workbook shall be saved/not saved
-    # @option opts [Boolean] :rw_change_excel Excel instance in which the workbook with the new
-    #                         write permissions shall be opened  :current (default), :new or an Excel instance
-    # @option opts [Boolean] :keep_open whether the workbook shall be kept open after unobtrusively opening
+    # @option opts [Boolean] :read_only true/false (default), open the workbook in read-only/read-write modus (save changes)
+    # @option opts [Boolean] :writable  true (default)/false changes of the workbook shall be saved/not saved
+    # @option opts [Boolean] :keep_open whether the workbook shall be kept open after unobtrusively opening (default: false)
     # @return [Workbook] a workbook
-    def self.unobtrusively(file, opts = { })
+    def self.unobtrusively(file_or_workbook, opts = { })
       opts = process_options(opts, :use_defaults => false)
-      opts = {:if_closed => :current,
-              :rw_change_excel => :current,
-              :keep_open => false}.merge(opts)
-      raise OptionInvalid, 'contradicting options' if opts[:writable] && opts[:read_only]
-      prefer_writable = ((!(opts[:read_only]) || opts[:writable] == true) &&
-                         !(opts[:read_only].nil? && opts[:writable] == false))
-      do_not_write = (opts[:read_only] || (opts[:read_only].nil? && opts[:writable] == false))
-      book = bookstore.fetch(file, :prefer_writable => prefer_writable)    
-      was_open = book && book.alive?
-      if was_open
-        was_saved = book.saved
-        was_writable = book.writable
+      raise OptionInvalid, 'contradicting options' if opts[:writable] && opts[:read_only]       
+      opts = opts.merge({:force => {:excel => opts[:if_closed]}, :if_closed => :current, 
+                         :if_unsaved => :accept, :keep_open => false})
+      opts = opts.merge({:read_only => opts[:read_only]}) unless opts[:read_only].nil?
+      file = (file_or_workbook.is_a? WIN32OLE) ? file_or_workbook.Fullname.tr('\\','/') : file_or_workbook
+      begin
+        book = open(file)
         was_visible = book.visible
-        was_calculation = book.calculation
+        was_writable = book.writable
+        was_saved = book.saved
         was_check_compatibility = book.check_compatibility
-        if (opts[:writable] && !was_writable && !was_saved) ||
-           (opts[:read_only] && was_writable && !was_saved)
+        was_calculation = book.excel.calculation
+        book.set_options(file,opts)
+        if !was_saved && ((opts[:writable] && !was_writable) || (opts[:read_only] && was_writable))
           raise NotImplementedREOError, 'unsaved read-only workbook shall be written'
         end
-        opts[:rw_change_excel] = book.excel if opts[:rw_change_excel] == :current
+        yield book
+      ensure
+        if book && book.alive?
+          do_not_write = (opts[:read_only] || (opts[:read_only].nil? && opts[:writable] == false))
+          book.save unless was_saved || do_not_write || book.ReadOnly
+          # open and close if the read_only mode has changed
+          if (opts[:read_only] && was_writable) || (!opts[:read_only] && !was_writable)
+            book = open(file, :read_only => !was_writable, :if_unsaved => :forget)
+          end
+          if book.was_open
+            book.visible = was_visible    
+            book.CheckCompatibility = was_check_compatibility
+            book.excel.calculation = was_calculation
+          end
+          book.Saved = (was_saved || !book.was_open)
+          book.close unless book.was_open || opts[:keep_open]
+        end
       end
-      change_rw_mode = ((opts[:read_only] && was_writable) || (opts[:writable] && !was_writable))
+    end
+
+    # allows to read or modify a workbook such that its state remains unchanged
+    # state comprises: open, saved, writable, visible, calculation mode, check compatibility
+    # @param [String] file_or_workbook     a file name or WIN32OLE workbook
+    # @param [Hash]   opts        the options
+    # @option opts [Variant] :if_closed  :current (default), :new or an Excel instance
+    # @option opts [Boolean] :read_only true/false (default), open the workbook in read-only/read-write modus (save changes)
+    # @option opts [Boolean] :writable  true (default)/false changes of the workbook shall be saved/not saved
+    # @option opts [Boolean] :keep_open whether the workbook shall be kept open after unobtrusively opening (default: false)
+    # @return [Workbook] a workbook
+=begin
+    def self.unobtrusively(file_or_workbook, opts = { })
+      book = new(file_or_workbook)
+      book.unobtrusively(opts)
+    end
+=end
+
+    def unobtrusively(opts = { })
+      opts = process_options(opts, :use_defaults => false)
+      raise OptionInvalid, 'contradicting options' if opts[:writable] && opts[:read_only]       
+      opts = opts.merge({:force => {:excel => opts[:if_closed]}, :if_closed => :current, 
+                         :if_unsaved => :accept, :keep_open => false})
+      opts = opts.merge({:read_only => opts[:read_only]}) unless opts[:read_only].nil?
+      file = stored_filename
       begin
-        book =
-          if was_open
-            if change_rw_mode
-              opts = opts.merge({:force => {:excel => opts[:rw_change_excel]}, :read_only => do_not_write})
-              open(file, opts)
-            else
-              book
-            end
-          else
-            opts = opts.merge({:force => {:excel => opts[:if_closed]}, :read_only => do_not_write})
-            open(file, opts)
-          end
+        book = open(file, opts)
+        was_visible = book.visible
+        was_saved = book.saved
+        was_writable = book.was_writable
+        was_check_compatibility = book.CheckCompatibility
+        was_calculation = book.excel.calculation
+        if !was_saved && ((opts[:writable] && !was_writable) || (opts[:read_only] && was_writable))
+          raise NotImplementedREOError, 'unsaved read-only workbook shall be written'
+        end        
         yield book
       ensure
         if book && book.alive?
+          do_not_write = (opts[:read_only] || (opts[:read_only].nil? && opts[:writable] == false))
           book.save unless book.saved || do_not_write || book.ReadOnly
-          if was_open
-            if opts[:rw_change_excel] == book.excel && change_rw_mode
-              book.close
-              opts = opts.merge({:force => {:excel => opts[:rw_change_excel]}, :read_only => !was_writable})
-              book = open(file, opts)           
-            end
+          # open and close if the read_only mode has changed
+          if (opts[:read_only] && was_writable) || (!opts[:read_only] && !was_writable)           
+            book = open(file, :read_only => !was_writable, :if_unsaved => :forget)
+          end
+          if book.was_open
+            book.visible = was_visible             
+            book.CheckCompatibility = was_check_compatibility            
             book.excel.calculation = was_calculation
-            book.CheckCompatibility = was_check_compatibility
-            # book.visible = was_visible  # not necessary
           end
-          book.Saved = (was_saved || !was_open)
-          book.close unless was_open || opts[:keep_open]
+          book.Saved = (was_saved || !book.was_open)
+          book.close unless book.was_open || opts[:keep_open]
         end
       end
     end
 
+
     # reopens a closed workbook
     # @options options
     def reopen(options = { })