robust_excel_ole 1.14 → 1.15

data/lib/robust_excel_ole/workbook.rb

@@ -18,7 +18,6 @@ module RobustExcelOle
     attr_accessor :stored_filename
     attr_accessor :color_if_modified
     attr_accessor :was_open
-    attr_reader :workbook
 
     alias ole_object ole_workbook
 
@@ -29,8 +28,8 @@ module RobustExcelOle
       :if_unsaved    => :raise,
       :if_obstructed => :raise,
       :if_absent     => :raise,
-      :if_exists => :raise,
-      :check_compatibility => false
+      :if_exists => :raise
+      #:check_compatibility => false
     }.freeze
 
     CORE_DEFAULT_OPEN_OPTS = {
@@ -100,7 +99,7 @@ module RobustExcelOle
         # 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])              
+            (excel_class.new(:reuse => true) if !::JRUBY_BUG_CONNECT) : excel_of(options[:force][:excel])              
         begin
           book = if File.exists?(file)
             bookstore.fetch(file, :prefer_writable => !(options[:read_only]),
@@ -110,7 +109,8 @@ module RobustExcelOle
           trace "#{$!.message}"
         end
         if book 
-          book.was_open = book.alive?
+          # 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 
           # 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) &&
@@ -151,7 +151,6 @@ module RobustExcelOle
       end      
       set_options(filename, options)
       bookstore.store(self)
-      @workbook = @excel.workbook = self
       r1c1_letters = @ole_workbook.Worksheets.Item(1).Cells.Item(1,1).Address(true,true,XlR1C1).gsub(/[0-9]/,'') #('ReferenceStyle' => XlR1C1).gsub(/[0-9]/,'')
       address_class.new(r1c1_letters)
       if block
@@ -232,43 +231,46 @@ module RobustExcelOle
 
     # @private    
     def ensure_workbook(filename, options)  
-      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]        
-        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)
-          else 
-            open_or_create_workbook(filename,options)
-          end
-        end       
+      return if (@ole_workbook && alive? && (options[:read_only].nil? || @ole_workbook.ReadOnly == options[:read_only]))
+      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
+      filename = @stored_filename ? @stored_filename : filename 
+      manage_nonexisting_file(filename,options)
+      excel_option = options[:force][:excel].nil? ? options[:default][:excel] : options[:force][:excel]        
+      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?
+        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(filename,options)
+          @was_open = @excel.Workbooks.Count == workbooks_number_before_connect
+        else 
+          open_or_create_workbook(filename,options)
+        end
+      end       
     end
 
     # @private
     def set_options(filename, options)
+      # changing read-only mode
       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)
+        ensure_workbook(filename, options)
       end
       retain_saved do
         self.visible = options[:force][:visible].nil? ? @excel.Visible : options[:force][:visible]
         @excel.calculation = options[:calculation] unless options[:calculation].nil?
         @ole_workbook.CheckCompatibility = options[:check_compatibility] unless options[:check_compatibility].nil?
-      end
+      end      
     end
 
-
   private
 
     # @private
@@ -299,9 +301,6 @@ 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
@@ -410,11 +409,13 @@ module RobustExcelOle
     end
     
     # @private
-    def open_or_create_workbook(filename, options)       
-      return if @ole_workbook && options[:if_unsaved] != :alert && options[:if_unsaved] != :excel
+    def open_or_create_workbook(filename, options)
+      return if @ole_workbook && options[:if_unsaved] != :alert && options[:if_unsaved] != :excel &&
+        (options[:read_only].nil? || options[:read_only]==@ole_workbook.ReadOnly )
       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}"
@@ -467,7 +468,7 @@ module RobustExcelOle
       workaround_condition = @excel.Version.split('.').first.to_i == 12 && workbooks.Count == 0
       if workaround_condition
         workbooks.Add
-        @excel.calculation = options[:calculation].nil? ? @excel.calculation : options[:calculation]
+        @excel.calculation = options[:calculation].nil? ? @excel.properties[:calculation] : options[:calculation]
       end
       begin
         # @excel.with_displayalerts(update_links_opt == :alert ? true : @excel.displayalerts) do
@@ -545,20 +546,20 @@ module RobustExcelOle
       end
     end
 
-    def self.for_reading(*args, &block)
-      args = args.dup
-      opts = args.last.is_a?(Hash) ? args.pop : {}
-      opts = {:writable => false}.merge(opts)
-      args.push opts
-      unobtrusively(*args, &block)
+    def for_reading(opts = { }, &block)
+      unobtrusively({:writable => false}.merge(opts), &block)
+    end
+
+    def for_modifying(opts = { }, &block)
+      unobtrusively({:writable => true}.merge(opts), &block)
     end
 
-    def self.for_modifying(*args, &block)
-      args = args.dup
-      opts = args.last.is_a?(Hash) ? args.pop : {}
-      opts = {:writable => true}.merge(opts)
-      args.push opts
-      unobtrusively(*args, &block)
+    def self.for_reading(arg, opts = { }, &block)
+      unobtrusively(arg, {:writable => false}.merge(opts), &block)
+    end
+
+    def self.for_modifying(arg, opts = { }, &block)
+      unobtrusively(arg, {:writable => true}.merge(opts), &block)
     end
 
     # allows to read or modify a workbook such that its state remains unchanged
@@ -570,32 +571,48 @@ module RobustExcelOle
     # @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_or_workbook, 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?
+    def self.unobtrusively(file_or_workbook, opts = { }, &block)
       file = (file_or_workbook.is_a? WIN32OLE) ? file_or_workbook.Fullname.tr('\\','/') : file_or_workbook
+      unobtrusively_opening(file, opts, nil, &block)
+    end
+
+    def unobtrusively(opts = { }, &block)
+      file = @stored_filename
+      self.class.unobtrusively_opening(file, opts, alive?, &block)
+    end
+
+    @private
+    def self.unobtrusively_opening(file, opts, book_is_alive, &block)
+      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?
+        prefer_writable = ((!(opts[:read_only]) || opts[:writable] == true) &&
+                           !(opts[:read_only].nil? && opts[:writable] == false))
+        known_book = bookstore.fetch(file, :prefer_writable => prefer_writable) 
+      end
+      excel_opts = if (book_is_alive==false || (book_is_alive.nil? && (known_book.nil? || !known_book.alive?)))
+        {:force => {:excel => opts[:if_closed]}}
+      else
+        {:force => {:excel => opts[:force][:excel]}, :default => {:excel => opts[:default][:excel]}}
+      end
+      open_opts = excel_opts.merge({:if_unsaved => :accept})
       begin
-        book = open(file)
+        book = open(file, open_opts)
         was_visible = book.visible
         was_writable = book.writable
         was_saved = book.saved
         was_check_compatibility = book.check_compatibility
-        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
+        was_calculation = book.excel.properties[:calculation]
+        book.set_options(file,opts) 
         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
+          do_not_write = opts[:read_only] || opts[:writable]==false
+          book.save unless book.saved || do_not_write || !book.writable
           if (opts[:read_only] && was_writable) || (!opts[:read_only] && !was_writable)
-            book = open(file, :read_only => !was_writable, :if_unsaved => :forget)
+            book.set_options(file, opts.merge({:read_only => !was_writable, 
+                                               :if_unsaved => (opts[:writable]==false ? :forget : :save)}))
           end
           if book.was_open
             book.visible = was_visible    
@@ -608,60 +625,6 @@ module RobustExcelOle
       end
     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 = 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
-          # 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
-    end
-
-
     # reopens a closed workbook
     # @options options
     def reopen(options = { })
@@ -857,7 +820,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 !::JRUBY_BUG_COPYSHEETS
           if sheet
             sheet.Copy({ after_or_before.to_s => base_sheet.ole_worksheet })
           else
@@ -990,7 +953,7 @@ module RobustExcelOle
     end
 
     def calculation
-      @excel.calculation if @ole_workbook
+      @excel.properties[:calculation] if @ole_workbook
     end
 
     # @private
@@ -1000,7 +963,7 @@ module RobustExcelOle
 
     # returns true, if the workbook is visible, false otherwise
     def visible
-      @excel.visible && @ole_workbook.Windows(@ole_workbook.Name).Visible
+      @excel.Visible && @ole_workbook.Windows(@ole_workbook.Name).Visible
     end
 
     # makes both the Excel instance and the window of the workbook visible, or the window invisible
@@ -1046,6 +1009,11 @@ module RobustExcelOle
       self.class.bookstore
     end
 
+    # @private
+    def workbook
+      self
+    end
+
     # @private
     def to_s    
       self.filename.to_s
@@ -1109,7 +1077,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 ::JRUBY_BUG_ERRORMESSAGE 
           begin
             @ole_workbook.send(name, *args)
           rescue Java::OrgRacobCom::ComFailException 

data/lib/robust_excel_ole/worksheet.rb

@@ -12,6 +12,7 @@ module RobustExcelOle
   class Worksheet < RangeOwners
 
     attr_reader :ole_worksheet
+    attr_reader :workbook
 
     def initialize(win32_worksheet)
       @ole_worksheet = win32_worksheet
@@ -27,12 +28,17 @@ module RobustExcelOle
     end
 
     def workbook
-      ole_workbook = self.Parent
-      saved_status = ole_workbook.Saved
-      ole_workbook.Saved = true unless saved_status
-      workbook = workbook_class.new(ole_workbook)
-      ole_workbook.Saved = saved_status
-      workbook
+      return @workbook unless @workbook.nil?
+      begin
+        ole_workbook = self.Parent
+        saved_status = ole_workbook.Saved
+        ole_workbook.Saved = true unless saved_status
+        @workbook = workbook_class.new(ole_workbook)
+        ole_workbook.Saved = saved_status
+      rescue
+        nil
+      end
+      @workbook
     end
 
     # sheet name
@@ -40,7 +46,7 @@ module RobustExcelOle
     def name
       @ole_worksheet.Name
     rescue
-      raise WorksheetREOError, "name #{name.inspect} could not be determined"
+      raise WorksheetREOError, "name could not be determined"
     end
 
     # sets sheet name
@@ -206,8 +212,7 @@ module RobustExcelOle
 
     # @private
     def to_s    
-      '#<Worksheet: ' + name.to_s + ">"
-      #'#<Worksheet: ' + ('not alive ' unless workbook.alive?).to_s + name.to_s + " #{File.basename(workbook.stored_filename)} >"
+      '#<Worksheet: ' + (workbook.nil? ? 'not alive ' : (name + ' ' + File.basename(workbook.stored_filename)).to_s) + ">"
     end
 
     # @private
@@ -220,7 +225,7 @@ module RobustExcelOle
     # @private
     def method_missing(name, *args)
       if name.to_s[0,1] =~ /[A-Z]/
-        if JRUBY_BUG_ERRORMESSAGE 
+        if ::JRUBY_BUG_ERRORMESSAGE 
           begin
             @ole_worksheet.send(name, *args)
           rescue Java::OrgRacobCom::ComFailException 

data/spec/excel_spec.rb

@@ -271,16 +271,16 @@ module RobustExcelOle
           ole_excel = WIN32OLE.new("Excel.Application")  
           reo_excel = Excel.new(ole_excel)
           reo_excel.ole_excel.Hwnd.should == ole_excel.Hwnd  
-          reo_excel.visible.should == false
-          reo_excel.displayalerts.should == :if_visible
+          reo_excel.Visible.should == false
+          reo_excel.properties[:displayalerts].should == :if_visible
         end
 
         it "lifts an Excel instance given as WIN32OLE object and set options" do
           app = WIN32OLE.new('Excel.Application')
           ole_excel = WIN32OLE.connect("Excel.Application")  
           reo_excel = Excel.new(ole_excel, {:displayalerts => true, :visible => true})
-          ole_excel.visible.should == true
-          ole_excel.displayalerts.should == true
+          ole_excel.Visible.should == true
+          ole_excel.DisplayAlerts.should == true
         end
 
 
@@ -889,6 +889,8 @@ module RobustExcelOle
           # "Yes" is to the left of "No", which is the  default. --> language independent
           @excel.should be_alive
           @key_sender.puts "{enter}" 
+          @key_sender.puts "{enter}" 
+          @key_sender.puts "{enter}" 
           result = @excel.close(:if_unsaved => :alert)
           @excel.should_not be_alive
           result.should == 1
@@ -920,6 +922,7 @@ module RobustExcelOle
           @book.saved.should be false
           @key_sender.puts "{left}{enter}"
           @key_sender.puts "{left}{enter}"
+          @key_sender.puts "{left}{enter}"
           expect{
             @excel.close(:if_unsaved => :alert)
             }.to raise_error(ExcelREOError, "user canceled or runtime error")
@@ -1254,55 +1257,55 @@ module RobustExcelOle
         excel2 = Excel.create
         excel1.focus
         excel1.Visible.should be true
-        excel1.visible.should be true
+        excel1.properties[:visible].should be true
       end
 
       it "should set default values" do
         excel1 = Excel.new
         excel1.Visible.should be false
         excel1.DisplayAlerts.should be false
-        excel1.visible.should be false
-        excel1.displayalerts.should == :if_visible
+        excel1.properties[:visible].should be false
+        excel1.properties[:displayalerts].should == :if_visible
       end
 
       it "should set visible true" do
         excel1 = Excel.new(:visible => true)
         excel1.Visible.should be true
         excel1.DisplayAlerts.should be true
-        excel1.visible.should be true
-        excel1.displayalerts.should == :if_visible
+        excel1.properties[:visible].should be true
+        excel1.properties[:displayalerts].should == :if_visible
       end
 
       it "should set visible false" do
         excel1 = Excel.new(:visible => false)
         excel1.Visible.should be false
         excel1.DisplayAlerts.should be false
-        excel1.visible.should be false
-        excel1.displayalerts.should == :if_visible
+        excel1.properties[:visible].should be false
+        excel1.properties[:displayalerts].should == :if_visible
       end
 
       it "should set displayalerts true" do
         excel1 = Excel.new(:displayalerts => true)
         excel1.Visible.should be false
         excel1.DisplayAlerts.should be true
-        excel1.visible.should be false
-        excel1.displayalerts.should be true
+        excel1.properties[:visible].should be false
+        excel1.properties[:displayalerts].should be true
       end
 
       it "should set displayalerts false" do
         excel1 = Excel.new(:displayalerts => false)
         excel1.Visible.should be false
         excel1.DisplayAlerts.should be false
-        excel1.visible.should be false
-        excel1.displayalerts.should be false
+        excel1.properties[:visible].should be false
+        excel1.properties[:displayalerts].should be false
       end
 
       it "should use values of the current Excel when reusing" do
         excel1 = Excel.create
         excel1.Visible.should be false
         excel1.DisplayAlerts.should be false
-        excel1.visible.should be false
-        excel1.displayalerts.should == :if_visible
+        excel1.properties[:visible].should be false
+        excel1.properties[:displayalerts].should == :if_visible
         excel1.Visible = true
         excel1.DisplayAlerts = true
         excel1.Visible.should be true
@@ -1316,49 +1319,49 @@ module RobustExcelOle
         excel1 = Excel.create
         excel2 = Excel.current
         excel2.Visible.should be false
-        excel2.visible.should be false
+        excel2.properties[:visible].should be false
         excel2.DisplayAlerts.should be false
-        excel2.displayalerts.should == :if_visible
+        excel2.properties[:displayalerts].should == :if_visible
       end
 
       it "should take Visible and DisplayAlerts from the connected Excel" do
         excel1 = Excel.create
         excel2 = Excel.current(:visible => true)
         excel2.Visible.should be true
-        excel2.visible.should be true
+        excel2.properties[:visible].should be true
         excel2.DisplayAlerts.should be true
-        excel2.displayalerts.should == :if_visible
+        excel2.properties[:displayalerts].should == :if_visible
       end
 
       it "should set Excel visible and invisible with current" do
         excel1 = Excel.new(:reuse => false, :visible => true)
         excel1.Visible.should be true
-        excel1.visible.should be true
+        excel1.properties[:visible].should be true
         excel1.DisplayAlerts.should be true
-        excel1.displayalerts.should == :if_visible
+        excel1.properties[:displayalerts].should == :if_visible
         excel1.visible = false
         excel1.Visible.should be false
-        excel1.visible.should be false
+        excel1.properties[:visible].should be false
         excel1.DisplayAlerts.should be false
-        excel1.displayalerts.should == :if_visible
+        excel1.properties[:displayalerts].should == :if_visible
         excel2 = Excel.current(:visible => true)
         excel2.Visible.should be true
-        excel2.visible.should be true
-        excel2.displayalerts.should == :if_visible
+        excel2.properties[:visible].should be true
+        excel2.properties[:displayalerts].should == :if_visible
         excel2.DisplayAlerts.should be true
       end
 
       it "should set Excel visible and invisible" do
         excel = Excel.new(:reuse => false, :visible => true)
         excel.Visible.should be true
-        excel.visible.should be true
+        excel.properties[:visible].should be true
         excel.DisplayAlerts.should be true
-        excel.displayalerts.should == :if_visible
+        excel.properties[:displayalerts].should == :if_visible
         excel.visible = false
         excel.Visible.should be false
-        excel.visible.should be false
+        excel.properties[:visible].should be false
         excel.DisplayAlerts.should be false
-        excel.displayalerts.should == :if_visible
+        excel.properties[:displayalerts].should == :if_visible
         excel7 = Excel.current
         excel7.should === excel
         excel7.Visible.should be false
@@ -1366,117 +1369,117 @@ module RobustExcelOle
         excel1 = Excel.create(:visible => true)
         excel1.should_not == excel
         excel1.Visible.should be true
-        excel1.visible.should be true
+        excel1.properties[:visible].should be true
         excel1.DisplayAlerts.should be true
-        excel1.displayalerts.should == :if_visible
+        excel1.properties[:displayalerts].should == :if_visible
         excel2 = Excel.create(:visible => false)
         excel2.Visible.should be false
-        excel2.visible.should be false
+        excel2.properties[:visible].should be false
         excel2.DisplayAlerts.should be false
-        excel2.displayalerts.should == :if_visible
+        excel2.properties[:displayalerts].should == :if_visible
         excel3 = Excel.current
         excel3.should === excel
         excel3.Visible.should be false
-        excel3.visible.should be false
+        excel3.properties[:visible].should be false
         excel3.DisplayAlerts.should be false
-        excel3.displayalerts.should == :if_visible
+        excel3.properties[:displayalerts].should == :if_visible
         excel4 = Excel.current(:visible => true)
         excel4.should === excel
         excel4.Visible.should be true
-        excel4.visible.should be true
+        excel4.properties[:visible].should be true
         excel4.DisplayAlerts.should be true
-        excel4.displayalerts.should == :if_visible
+        excel4.properties[:displayalerts].should == :if_visible
         excel5 = Excel.current(:visible => false)
         excel5.should === excel
         excel5.Visible.should be false
-        excel5.visible.should be false
+        excel5.properties[:visible].should be false
         excel5.DisplayAlerts.should be false
-        excel5.displayalerts.should == :if_visible
+        excel5.properties[:displayalerts].should == :if_visible
       end
 
       it "should enable or disable Excel DispayAlerts" do        
         excel = Excel.new(:reuse => false, :displayalerts => true)
         excel.DisplayAlerts.should be true
-        excel.displayalerts.should be true
+        excel.properties[:displayalerts].should be true
         excel.Visible.should be false
-        excel.visible.should be false
+        excel.properties[:visible].should be false
         excel6 = Excel.current
         excel6.should === excel
         excel6.DisplayAlerts.should be true
-        excel6.displayalerts.should be true
+        excel6.properties[:displayalerts].should be true
         excel6.Visible.should be false
-        excel6.visible.should be false
+        excel6.properties[:visible].should be false
         excel.displayalerts = false
         excel.DisplayAlerts.should be false
-        excel.displayalerts.should be false
+        excel.properties[:displayalerts].should be false
         excel.Visible.should be false
-        excel.visible.should be false
+        excel.properties[:visible].should be false
         excel7 = Excel.current
         excel7.should === excel
         excel7.DisplayAlerts.should be false
-        excel7.displayalerts.should be false
+        excel7.properties[:displayalerts].should be false
         excel7.Visible.should be false
-        excel7.visible.should be false
+        excel7.properties[:visible].should be false
         excel1 = Excel.create(:displayalerts => true)
         excel1.should_not == excel
         excel1.DisplayAlerts.should be true
-        excel1.displayalerts.should be true
+        excel1.properties[:displayalerts].should be true
         excel1.Visible.should be false
-        excel1.visible.should be false
+        excel1.properties[:visible].should be false
         excel2 = Excel.create(:displayalerts => false)
         excel2.DisplayAlerts.should be false
-        excel2.displayalerts.should be false
+        excel2.properties[:displayalerts].should be false
         excel2.Visible.should be false
-        excel2.visible.should be false
+        excel2.properties[:visible].should be false
         excel3 = Excel.current
         excel3.should === excel
         excel3.DisplayAlerts.should be false
-        excel3.displayalerts.should be false
+        excel3.properties[:displayalerts].should be false
         excel3.Visible.should be false
-        excel3.visible.should be false
+        excel3.properties[:visible].should be false
         excel4 = Excel.current(:displayalerts => true)
         excel4.should === excel
         excel4.DisplayAlerts.should be true
-        excel4.displayalerts.should be true
+        excel4.properties[:displayalerts].should be true
         excel4.Visible.should be false
-        excel4.visible.should be false
+        excel4.properties[:visible].should be false
         excel5 = Excel.current(:displayalerts => false)
         excel5.should === excel
         excel5.DisplayAlerts.should be false
-        excel5.displayalerts.should be false
+        excel5.properties[:displayalerts].should be false
         excel5.Visible.should be false
-        excel5.visible.should be false
+        excel5.properties[:visible].should be false
       end
 
       it "should set Excel visible and displayalerts" do        
         excel = Excel.new(:reuse => false, :visible => true, :displayalerts => true)
         excel.DisplayAlerts.should be true
-        excel.displayalerts.should be true
+        excel.properties[:displayalerts].should be true
         excel.Visible.should be true
-        excel.visible.should be true
+        excel.properties[:visible].should be true
         excel6 = Excel.current
         excel6.should === excel
         excel6.DisplayAlerts.should be true
-        excel6.displayalerts.should be true
+        excel6.properties[:displayalerts].should be true
         excel6.Visible.should be true
-        excel6.visible.should be true
+        excel6.properties[:visible].should be true
         excel.displayalerts = false
         excel.DisplayAlerts.should be false
-        excel.displayalerts.should be false
+        excel.properties[:displayalerts].should be false
         excel.Visible.should be true
-        excel.visible.should be true
+        excel.properties[:visible].should be true
         excel7 = Excel.current
         excel7.should === excel
         excel7.DisplayAlerts.should be false
-        excel7.displayalerts.should be false
+        excel7.properties[:displayalerts].should be false
         excel7.Visible.should be true
-        excel7.visible.should be true        
+        excel7.properties[:visible].should be true        
         excel2 = Excel.new(:reuse => false, :visible => true, :displayalerts => true)
         excel2.visible = false
         excel2.DisplayAlerts.should be true
-        excel2.displayalerts.should be true
+        excel2.properties[:displayalerts].should be true
         excel2.Visible.should be false
-        excel2.visible.should be false
+        excel2.properties[:visible].should be false
         excel3 = Excel.new(:reuse => false, :visible => true, :displayalerts => false)
         excel3.Visible.should be true
         excel3.DisplayAlerts.should be false
@@ -1488,21 +1491,21 @@ module RobustExcelOle
         excel3.DisplayAlerts.should be false
         excel4 = Excel.create(:visible => true, :displayalerts => true)
         excel4.DisplayAlerts.should be true
-        excel4.displayalerts.should be true
+        excel4.properties[:displayalerts].should be true
         excel4.Visible.should be true
-        excel4.visible.should be true
+        excel4.properties[:visible].should be true
         excel5 = Excel.current(:visible => true, :displayalerts => false)
         excel5.should === excel
         excel5.DisplayAlerts.should be false
-        excel5.displayalerts.should be false
+        excel5.properties[:displayalerts].should be false
         excel5.Visible.should be true
-        excel5.visible.should be true
+        excel5.properties[:visible].should be true
         excel6 = Excel.current(:visible => false, :displayalerts => true)
         excel6.should === excel
         excel6.DisplayAlerts.should be true
-        excel6.displayalerts.should be true
+        excel6.properties[:displayalerts].should be true
         excel6.Visible.should be false
-        excel6.visible.should be false
+        excel6.properties[:visible].should be false
       end
 
       it "should work with displayalerts == if_visible" do
@@ -1623,17 +1626,17 @@ module RobustExcelOle
 
       it "should create and reuse Excel with calculation mode" do
         excel1 = Excel.create(:calculation => :manual)
-        excel1.calculation.should == :manual
+        excel1.properties[:calculation].should == :manual
         excel2 = Excel.create(:calculation => :automatic)
-        excel2.calculation.should == :automatic
+        excel2.properties[:calculation].should == :automatic
         excel3 = Excel.current
-        excel3.calculation.should == :manual
+        excel3.properties[:calculation].should == :manual
         excel4 = Excel.current(:calculation => :automatic)
-        excel4.calculation.should == :automatic
+        excel4.properties[:calculation].should == :automatic
         excel5 = Excel.new(:reuse => false)
-        excel5.calculation.should == nil
+        excel5.properties[:calculation].should == nil
         excel6 = Excel.new(:reuse => false, :calculation => :manual)
-        excel6.calculation.should == :manual
+        excel6.properties[:calculation].should == :manual
       end
 
 =begin
@@ -1657,11 +1660,11 @@ module RobustExcelOle
         old_calculation_mode = @excel1.Calculation
         old_calculatebeforesave = @excel1.CalculateBeforeSave
         @excel1.calculation = :automatic
-        @excel1.calculation.should == :automatic
+        @excel1.properties[:calculation].should == :automatic
         @excel1.Calculation.should == old_calculation_mode 
         @excel1.CalculateBeforeSave.should == old_calculatebeforesave
         @excel1.calculation = :manual
-        @excel1.calculation.should == :manual
+        @excel1.properties[:calculation].should == :manual
         @excel1.Calculation.should == old_calculation_mode
         @excel1.CalculateBeforeSave.should == old_calculatebeforesave
       end
@@ -1673,7 +1676,7 @@ module RobustExcelOle
           book1 = Workbook.open(@simple_file1, :visible => false)
           expect( book1.Windows(1).Visible ).to be true # false
           expect {       excel1.calculation = :manual 
-            }.to change{ excel1.calculation 
+            }.to change{ excel1.properties[:calculation] 
           }.from(        :automatic
           ).to(          :manual )
         end
@@ -1683,7 +1686,7 @@ module RobustExcelOle
           book1 = Workbook.open(@simple_file1, :visible => false)
           expect( book1.Windows(1).Visible ).to be true # false
           expect {       excel1.calculation = :automatic 
-            }.to change{ excel1.calculation 
+            }.to change{ excel1.properties[:calculation] 
           }.from(        :manual
           ).to(          :automatic )
         end
@@ -1694,7 +1697,7 @@ module RobustExcelOle
         book = Workbook.open(@simple_file, :visible => true)
         old_calculation_mode = @excel1.Calculation
         @excel1.with_calculation(:manual) do
-          @excel1.calculation.should == :manual
+          @excel1.properties[:calculation].should == :manual
           @excel1.Calculation.should == XlCalculationManual
           @excel1.CalculateBeforeSave.should be false
           book.Saved.should be true
@@ -1702,7 +1705,7 @@ module RobustExcelOle
         @excel1.Calculation.should == old_calculation_mode
         @excel1.CalculateBeforeSave.should be false
         @excel1.with_calculation(:automatic) do
-          @excel1.calculation.should == :automatic
+          @excel1.properties[:calculation].should == :automatic
           @excel1.Calculation.should == XlCalculationAutomatic
           @excel1.CalculateBeforeSave.should be false
           book.Saved.should be false
@@ -1717,7 +1720,7 @@ module RobustExcelOle
         book.Saved.should be true
         book.Windows(book.Name).Visible = true
         @excel1.calculation = :manual
-        @excel1.calculation.should == :manual
+        @excel1.properties[:calculation].should == :manual
         @excel1.Calculation.should == XlCalculationManual
         @excel1.CalculateBeforeSave.should be false
         book.Saved.should be true
@@ -1728,7 +1731,7 @@ module RobustExcelOle
         book = Workbook.open(@simple_file, :visible => true)
         book.Saved.should be true
         @excel1.calculation = :automatic
-        @excel1.calculation.should == :automatic
+        @excel1.properties[:calculation].should == :automatic
         @excel1.Calculation.should == XlCalculationAutomatic
         @excel1.CalculateBeforeSave.should be false
         book.Saved.should be true
@@ -1741,7 +1744,7 @@ module RobustExcelOle
         book.Saved.should be false
         book.Windows(book.Name).Visible = true
         @excel1.calculation = :manual
-        @excel1.calculation.should == :manual
+        @excel1.properties[:calculation].should == :manual
         @excel1.Calculation.should == XlCalculationManual
         @excel1.CalculateBeforeSave.should be false
         book.Saved.should be false
@@ -1753,7 +1756,7 @@ module RobustExcelOle
         book.sheet(1)[1,1] = "foo"
         book.Saved.should be false
         @excel1.calculation = :automatic
-        @excel1.calculation.should == :automatic
+        @excel1.properties[:calculation].should == :automatic
         @excel1.Calculation.should == XlCalculationAutomatic
         @excel1.CalculateBeforeSave.should be false
         book.Saved.should be false
@@ -1770,7 +1773,7 @@ module RobustExcelOle
         @excel1 = Excel.new
         b = Workbook.open(@simple_file, :visible => true)
         @excel1.Calculation = XlCalculationManual
-        @excel1.calculation.should == :manual
+        @excel1.properties[:calculation].should == :manual
         @excel1.Calculation.should == XlCalculationManual
       end
 
@@ -1778,7 +1781,7 @@ module RobustExcelOle
         @excel1 = Excel.new
         b = Workbook.open(@simple_file, :visible => true)
         @excel1.Calculation = XlCalculationAutomatic
-        @excel1.calculation.should == :automatic
+        @excel1.properties[:calculation].should == :automatic
         @excel1.Calculation.should == XlCalculationAutomatic
       end
 
@@ -2096,7 +2099,6 @@ module RobustExcelOle
       end
 
     end
-  
 
     describe "namevalue_glob, set_namevalue_glob" do