robust_excel_ole 1.15 → 1.16

data/lib/robust_excel_ole/version.rb

@@ -1,3 +1,3 @@
 module RobustExcelOle
-  VERSION = "1.15"
+  VERSION = "1.16"
 end

data/lib/robust_excel_ole/workbook.rb

@@ -12,32 +12,33 @@ 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 :ole_workbook
+    attr_reader :excel
+    attr_reader :stored_filename
 
     alias ole_object ole_workbook
 
-    DEFAULT_OPEN_OPTS = {
-      :default => {:excel => :current},
+    CORE_DEFAULT_OPEN_OPTS = {
+      :default => {:excel => :current}, 
       :force => {},
-      :update_links => :never,
+      :update_links => :never
+    }.freeze
+
+    DEFAULT_OPEN_OPTS = {
       :if_unsaved    => :raise,
       :if_obstructed => :raise,
       :if_absent     => :raise,
       :if_exists => :raise
-      #:check_compatibility => false
-    }.freeze
-
-    CORE_DEFAULT_OPEN_OPTS = {
-      :default => {:excel => :current}, :force => {}, :update_links => :never
-    }.freeze
+    }.merge(CORE_DEFAULT_OPEN_OPTS).freeze  
 
-    ABBREVIATIONS = [[:default,:d], [:force, :f], [:excel, :e], [:visible, :v],
-                     [:if_obstructed, :if_blocked]].freeze
+    ABBREVIATIONS = [
+      [:default,:d],
+      [:force, :f],
+      [:excel, :e],
+      [:visible, :v],
+      [:if_obstructed, :if_blocked]
+    ].freeze
 
 
     # opens a workbook.
@@ -83,51 +84,56 @@ module RobustExcelOle
     # :visible              true -> makes the workbook visible
     # :check_compatibility  true -> check compatibility when saving
     # :update_links         true -> user is being asked how to update links, false -> links are never updated
-    # @return [Workbook] a representation of a workbook
+    # @return [Workbook] a representation of a workbook   
     def self.new(file_or_workbook, opts = { }, &block)
-      options = process_options(opts)
-      if file_or_workbook.is_a? WIN32OLE
+      process_options(opts)
+      case file_or_workbook
+      when NilClass
+        raise FileNameNotGiven, 'filename is nil' 
+      when WIN32OLE
         file = file_or_workbook.Fullname.tr('\\','/') 
-      else
+      when Workbook
+        return file_or_workbook
+      when String
         file = file_or_workbook
-        raise(FileNameNotGiven, 'filename is nil') if file.nil?
-        raise(FileNotFound, "file #{General.absolute_path(file).inspect} is a directory") if File.directory?(file)
+        raise FileNotFound, "file #{General.absolute_path(file).inspect} is a directory" if File.directory?(file)
+      else
+        raise TypeREOError, 'given object is neither a filename, a Win32ole, nor a Workbook object'
       end
       # try to fetch the workbook from the bookstore
+      set_was_open opts, file_or_workbook.is_a?(WIN32OLE)
       book = nil
-      if options[:force][:excel] != :new
+      if opts[:force][:excel] != :new
         # if readonly is true, then prefer a book that is given in force_excel if this option is set              
         forced_excel = 
-          (options[:force][:excel].nil? || options[:force][:excel] == :current) ? 
-            (excel_class.new(:reuse => true) if !::JRUBY_BUG_CONNECT) : excel_of(options[:force][:excel])              
+          (opts[:force][:excel].nil? || opts[:force][:excel] == :current) ? 
+            (excel_class.new(:reuse => true) if !::CONNECT_JRUBY_BUG) : excel_of(opts[:force][:excel])              
         begin
           book = if File.exists?(file)
-            bookstore.fetch(file, :prefer_writable => !(options[:read_only]),
-                                  :prefer_excel    => (options[:read_only] ? forced_excel : nil))
+            bookstore.fetch(file, :prefer_writable => !(opts[:read_only]),
+                                  :prefer_excel    => (opts[:read_only] ? forced_excel : nil))
           end
         rescue
+          raise
           trace "#{$!.message}"
         end
         if book 
-          # hack (unless condition): calling Worksheet[]= causes calling Worksheet#workbook which calls Workbook#new(ole_workbook)
-          book.was_open = book.alive? unless file_or_workbook.is_a? WIN32OLE 
+          set_was_open opts, 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) &&
-            !(book.alive? && !book.saved && (options[:if_unsaved] != :accept))
-            options[:force][:excel] = book.excel if book.excel && book.excel.alive?
-            book.ensure_workbook(file,options)
-            book.set_options(file,options)
+          if (opts[:force][:excel].nil? || opts[:force][:excel] == :current || forced_excel == book.excel) &&
+            !(book.alive? && !book.saved && (opts[:if_unsaved] != :accept))
+            opts[:force][:excel] = book.excel if book.excel && book.excel.alive?
+            book.ensure_workbook(file,opts)
+            book.set_options(file,opts)
             return book
           end
         end
       end        
-      super(file_or_workbook, options, &block)
+      super(file_or_workbook, opts, &block)
     end
 
-    def self.open(file_or_workbook, opts = { }, &block)
-      new(file_or_workbook, opts, &block)
-    end
+    singleton_class.send :alias_method, :open, :new
 
     # creates a new Workbook object, if a file name is given
     # Promotes the win32ole workbook to a Workbook object, if a win32ole-workbook is given
@@ -135,7 +141,7 @@ module RobustExcelOle
     # @param [Hash]    opts             
     # @option opts [Symbol] see above
     # @return [Workbook] a workbook
-    def initialize(file_or_workbook, options = { }, &block)
+    def initialize(file_or_workbook, options, &block)
       if file_or_workbook.is_a? WIN32OLE
         @ole_workbook = file_or_workbook
         ole_excel = begin
@@ -150,8 +156,8 @@ module RobustExcelOle
         ensure_workbook(filename, options)        
       end      
       set_options(filename, options)
-      bookstore.store(self)
-      r1c1_letters = @ole_workbook.Worksheets.Item(1).Cells.Item(1,1).Address(true,true,XlR1C1).gsub(/[0-9]/,'') #('ReferenceStyle' => XlR1C1).gsub(/[0-9]/,'')
+      store_myself
+      r1c1_letters = @ole_workbook.Worksheets.Item(1).Cells.Item(1,1).Address(true,true,XlR1C1).gsub(/[0-9]/,'')
       address_class.new(r1c1_letters)
       if block
         begin
@@ -164,41 +170,53 @@ module RobustExcelOle
  
   private    
 
+    # @private
+    def self.set_was_open(hash, value)
+      hash[:was_open] = value if hash.has_key?(:was_open)
+    end
+
+    # @private
+    def set_was_open(hash, value)
+      self.class.set_was_open(hash, value)
+    end
+
+    # @private
     # translates abbreviations and synonyms and merges with default options
-    def self.process_options(options, proc_opts = {:use_defaults => true})
-      translator = proc do |opts|
-        erg = {}
-        opts.each do |key,value|
-          new_key = key
-          ABBREVIATIONS.each { |long,short| new_key = long if key == short }
-          if value.is_a?(Hash)
-            erg[new_key] = {}
-            value.each do |k,v|
-              new_k = k
-              ABBREVIATIONS.each { |l,s| new_k = l if k == s }
-              erg[new_key][new_k] = v
-            end
-          else
-            erg[new_key] = value
+    def self.process_options(opts, proc_opts = {:use_defaults => true})
+      translate(opts)
+      default_opts = (proc_opts[:use_defaults] ? DEFAULT_OPEN_OPTS : CORE_DEFAULT_OPEN_OPTS).dup
+      translate(default_opts)
+      opts.merge!(default_opts) {|key, v1, v2| v1 }
+      opts[:default] = default_opts[:default].merge(opts[:default]) unless opts[:default].nil?
+      opts[:force] = default_opts[:force].merge(opts[:force]) unless opts[:force].nil?
+    end
+
+    # @private
+    def self.translate(opts)
+      erg = {}
+      opts.each do |key,value|
+        new_key = key
+        ABBREVIATIONS.each { |long,short| new_key = long if key == short }
+        if value.is_a?(Hash)
+          erg[new_key] = {}
+          value.each do |k,v|
+            new_k = k
+            ABBREVIATIONS.each { |l,s| new_k = l if k == s }
+            erg[new_key][new_k] = v
           end
+        else
+          erg[new_key] = value
         end
-        erg[:default] ||= {}
-        erg[:force] ||= {}
-        force_list = [:visible, :excel]
-        erg.each { |key,value| erg[:force][key] = value if force_list.include?(key) }
-        erg[:default][:excel] = erg[:default_excel] unless erg[:default_excel].nil?
-        erg[:force][:excel] = erg[:force_excel] unless erg[:force_excel].nil?
-        erg[:default][:excel] = :current if erg[:default][:excel] == :reuse || erg[:default][:excel] == :active
-        erg[:force][:excel] = :current if erg[:force][:excel] == :reuse || erg[:force][:excel] == :active
-        erg
       end
-      opts = translator.call(options)
-      default_open_opts = proc_opts[:use_defaults] ? DEFAULT_OPEN_OPTS : CORE_DEFAULT_OPEN_OPTS        
-      default_opts = translator.call(default_open_opts)
-      opts = default_opts.merge(opts)
-      opts[:default] = default_opts[:default].merge(opts[:default]) unless opts[:default].nil?
-      opts[:force] = default_opts[:force].merge(opts[:force]) unless opts[:force].nil?
-      opts
+      opts.merge!(erg)
+      opts[:default] ||= {}
+      opts[:force] ||= {}
+      force_list = [:visible, :excel]
+      opts.each { |key,value| opts[:force][key] = value if force_list.include?(key) }
+      opts[:default][:excel] = opts[:default_excel] unless opts[:default_excel].nil?
+      opts[:force][:excel] = opts[:force_excel] unless opts[:force_excel].nil?
+      opts[:default][:excel] = :current if opts[:default][:excel] == :reuse || opts[:default][:excel] == :active
+      opts[:force][:excel] = :current if opts[:force][:excel] == :reuse || opts[:force][:excel] == :active
     end
 
     # returns an Excel object when given Excel, Workbook or Win32ole object representing a Workbook or an Excel
@@ -231,7 +249,9 @@ module RobustExcelOle
 
     # @private    
     def ensure_workbook(filename, options)  
+      set_was_open options, true
       return if (@ole_workbook && alive? && (options[:read_only].nil? || @ole_workbook.ReadOnly == options[:read_only]))
+      set_was_open options, false
       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"
@@ -242,16 +262,14 @@ module RobustExcelOle
       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 if @was_open.nil? # necessary?
+      if @ole_workbook && alive?
+        set_was_open options, true #if @was_open.nil? # necessary?
         manage_blocking_or_unsaved_workbook(filename,options)
         open_or_create_workbook(filename,options) if @ole_workbook.ReadOnly != options[:read_only]
       else
         if excel_option.nil? || excel_option == :current &&  
-          (!::JRUBY_BUG_CONNECT || filename[0] != '/')
-          workbooks_number_before_connect = @excel.Workbooks.Count
+          (!::CONNECT_JRUBY_BUG || filename[0] != '/')
           connect(filename,options)
-          @was_open = @excel.Workbooks.Count == workbooks_number_before_connect
         else 
           open_or_create_workbook(filename,options)
         end
@@ -275,15 +293,10 @@ module RobustExcelOle
 
     # @private
     # 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)
+    def connect(filename,options)   
+      workbooks_number = excel_class.excels_number==0 ? 0 : excel_class.current.Workbooks.Count
       @ole_workbook = begin
-        WIN32OLE.connect(abs_filename)
+        WIN32OLE.connect(General.absolute_path(filename))
       rescue
         if $!.message =~ /moniker/
           raise WorkbookConnectingBlockingError
@@ -300,6 +313,7 @@ module RobustExcelOle
           raise WorkbookConnectingUnknownError
         end
       end
+      set_was_open options, (ole_excel.Workbooks.Count == workbooks_number)
       @excel = excel_class.new(ole_excel)
     end
 
@@ -324,9 +338,11 @@ module RobustExcelOle
 
     # @private
     def manage_blocking_or_unsaved_workbook(filename,options)
-      obstructed_by_other_book = if (File.basename(filename) == File.basename(@ole_workbook.Fullname)) 
-        General.absolute_path(filename) != @ole_workbook.Fullname
-      end      
+      filename = General.absolute_path(filename)
+      filename = General.canonize(filename)
+      previous_file = General.canonize(@ole_workbook.Fullname)
+      obstructed_by_other_book = (File.basename(filename) == File.basename(previous_file)) &&
+                                 (File.dirname(filename) != File.dirname(previous_file)) 
       if obstructed_by_other_book
         # workbook is being obstructed by a workbook with same name and different path
         manage_blocking_workbook(filename,options)        
@@ -415,7 +431,6 @@ module RobustExcelOle
       begin
         abs_filename = General.absolute_path(filename)
         begin
-          @was_open = false if @was_open.nil?
           workbooks = @excel.Workbooks
         rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
           raise UnexpectedREOError, "cannot access workbooks: #{msg.message} #{msg.backtrace}"
@@ -427,7 +442,7 @@ module RobustExcelOle
                                       updatelinks_vba(options[:update_links]), 
                                       options[:read_only] )
           end
-        rescue WIN32OLERuntimeError => msg
+        rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
           # for Excel2007: for option :if_unsaved => :alert and user cancels: this error appears?
           # if yes: distinguish these events
           raise UnexpectedREOError, "cannot open workbook: #{msg.message} #{msg.backtrace}"
@@ -436,10 +451,10 @@ module RobustExcelOle
           # workaround for bug in Excel 2010: workbook.Open does not always return the workbook when given file name
           begin
             @ole_workbook = workbooks.Item(File.basename(filename))
-          rescue WIN32OLERuntimeError => msg
+          rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
             raise UnexpectedREOError, "WIN32OLERuntimeError: #{msg.message}"
           end
-        rescue WIN32OLERuntimeError => msg
+        rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
           raise UnexpectedREOError, "WIN32OLERuntimeError: #{msg.message} #{msg.backtrace}"
         end
       end
@@ -451,10 +466,10 @@ module RobustExcelOle
     # parameter 'UpdateLinks' has no effect
     def updatelinks_vba(updatelinks_reo)
       case updatelinks_reo
-      when :alert then RobustExcelOle::XlUpdateLinksUserSetting
-      when :never then RobustExcelOle::XlUpdateLinksNever
+      when :alert  then RobustExcelOle::XlUpdateLinksUserSetting
+      when :never  then RobustExcelOle::XlUpdateLinksNever
       when :always then RobustExcelOle::XlUpdateLinksAlways
-      else RobustExcelOle::XlUpdateLinksNever
+      else              RobustExcelOle::XlUpdateLinksNever
       end
     end
 
@@ -583,7 +598,7 @@ module RobustExcelOle
 
     @private
     def self.unobtrusively_opening(file, opts, book_is_alive, &block)
-      opts = process_options(opts)
+      process_options(opts)
       opts = {:if_closed => :current, :keep_open => false}.merge(opts)    
       raise OptionInvalid, 'contradicting options' if opts[:writable] && opts[:read_only] 
       if book_is_alive.nil?
@@ -598,6 +613,7 @@ module RobustExcelOle
       end
       open_opts = excel_opts.merge({:if_unsaved => :accept})
       begin
+        open_opts[:was_open] = nil
         book = open(file, open_opts)
         was_visible = book.visible
         was_writable = book.writable
@@ -614,13 +630,14 @@ module RobustExcelOle
             book.set_options(file, opts.merge({:read_only => !was_writable, 
                                                :if_unsaved => (opts[:writable]==false ? :forget : :save)}))
           end
-          if book.was_open
+          was_open = open_opts[:was_open]
+          if 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]
+          book.Saved = (was_saved || !was_open)
+          book.close unless was_open || opts[:keep_open]
         end
       end
     end
@@ -671,12 +688,12 @@ module RobustExcelOle
     #                  :close_if_saved      -> closes the blocking workbook, if it is saved,
     #                                          otherwise raises an exception   
     # @return [Workbook], the book itself, if successfully saved, raises an exception otherwise
-    def save_as(file, opts = { })
+    def save_as(file, options = { })
       raise FileNameNotGiven, 'filename is nil' if file.nil?
       raise ObjectNotAlive, 'workbook is not alive' unless alive?
       raise WorkbookReadOnly, 'Not opened for writing (opened with :read_only option)' if @ole_workbook.ReadOnly
       raise(FileNotFound, "file #{General.absolute_path(file).inspect} is a directory") if File.directory?(file)
-      options = self.class.process_options(opts)      
+      self.class.process_options(options)      
       if File.exist?(file)
         case options[:if_exists]
         when :overwrite
@@ -731,6 +748,11 @@ module RobustExcelOle
 
   private
 
+    def store_myself
+      bookstore.store(self)
+      @stored_filename = filename
+    end
+
     # @private
     def save_as_workbook(file, options)  
       dirname, basename = File.split(file)
@@ -741,7 +763,7 @@ module RobustExcelOle
         when '.xlsm' then RobustExcelOle::XlOpenXMLWorkbookMacroEnabled
         end
       @ole_workbook.SaveAs(General.absolute_path(file), file_format)
-      bookstore.store(self)
+      store_myself
     rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
       if msg.message =~ /SaveAs/ && msg.message =~ /Workbook/
         # trace "save: canceled by user" if options[:if_exists] == :alert || options[:if_exists] == :excel
@@ -820,7 +842,7 @@ module RobustExcelOle
       last_sheet_local = last_sheet
       after_or_before, base_sheet = opts.to_a.first || [:after, last_sheet_local]
       begin
-        if !::JRUBY_BUG_COPYSHEETS
+        if !::COPYSHEETS_JRUBY_BUG
           if sheet
             sheet.Copy({ after_or_before.to_s => base_sheet.ole_worksheet })
           else
@@ -857,9 +879,7 @@ module RobustExcelOle
       rescue WIN32OLERuntimeError, NameNotFound, Java::OrgRacobCom::ComFailException
         raise WorksheetREOError, "could not add given worksheet #{sheet.inspect}"
       end
-      #ole_sheet = @excel.Activesheet
       ole_sheet = ole_workbook.Activesheet
-      #ole_sheet = ole_sheet.nil? ? ole_workbook.Worksheets.Item(ole_workbook.Worksheets.Count) : ole_sheet
       new_sheet = worksheet_class.new(ole_sheet)
       new_sheet.name = new_sheet_name if new_sheet_name
       new_sheet
@@ -894,17 +914,14 @@ module RobustExcelOle
     # @param [String]  name  the name of the range
     # @param [Variant] value the contents of the range
     def []= (name, value)
-      old_color_if_modified = @color_if_modified
-      workbook.color_if_modified = 42  # 42 - aqua-marin, 4-green
-      set_namevalue_glob(name,value)   
-      workbook.color_if_modified = old_color_if_modified
+      set_namevalue_glob(name,value,:color => 42)   
     end
 
     # sets options
     # @param [Hash] opts
     def for_this_workbook(opts)
       return unless alive?
-      opts = self.class.process_options(opts, :use_defaults => false)
+      self.class.process_options(opts, :use_defaults => false)
       visible_before = visible
       check_compatibility_before = check_compatibility
       unless opts[:read_only].nil?
@@ -1077,7 +1094,7 @@ module RobustExcelOle
     def method_missing(name, *args) 
       if name.to_s[0,1] =~ /[A-Z]/
         raise ObjectNotAlive, 'method missing: workbook not alive' unless alive?
-        if ::JRUBY_BUG_ERRORMESSAGE 
+        if ::ERRORMESSAGE_JRUBY_BUG 
           begin
             @ole_workbook.send(name, *args)
           rescue Java::OrgRacobCom::ComFailException