robust_excel_ole 1.36 → 1.37

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d53d040d2a0079556bfca8d89a531f65b75f8e27d361378e339d38ac8ec7fdf
-  data.tar.gz: 68658a532b13b21815f61e5ce7a286b8df42693711142ee7ff9c15c26cf6fa07
+  metadata.gz: 646308c3740c8716d9fb91b9c0288edc6e915c060bdd713401980608d412119a
+  data.tar.gz: 379a3bd099724e9cd6adc2542d804d4f4737eafc47742892dbc1ba4914f7b7c2
 SHA512:
-  metadata.gz: '08f8abee9ca47bf37d4d27e3d13ecfcb31f1ae019370450bb052911ccd5a56ec5116c007d1f1475c19a29226857281f7d9d80747c5d2e5a7ac605de5d4d96660'
-  data.tar.gz: 7243013b9b0af1c07c0e0eebb240c448be063d55f0dc5e2e15919df474aec957c444e45211eea4c093288e429111e3057f1860d7cc49ab4ffa5d160744a490cd
+  metadata.gz: '02308d88008a6e7d5362b0c793f1ab4e55025b7df0d19741dbe66775450f672b654c9766ac3e49d6ec840d497b9fa39befd1f66e6d20e5a5539d6cf3eefbc276'
+  data.tar.gz: 874eaf4089951eb94ac101699198e35981b72084036eb171ec70eb69dc2c135951138f773844b945ff7f4ebbd8d3a4020f3bdaf3f4286f165334e270ada23118

data/Changelog

@@ -1,6 +1,11 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
+## [1.37] 2021-30-11
+
+### Added
+  - Excel#visible,displayalerts
+
 ## [1.36] 2021-29-10
 
 ### Added

data/docs/README_open.rdoc

@@ -42,7 +42,7 @@ The options are the following:
 +:if_blocked+::         specifies behaviour if the workbook is blocked by another book (default: +:raise+)
 
 
-+:read_only+::          opens in read-only mode (default: +false+)
++:read_only+::          opens in read-only (+true+) or read-write mode (+false+) (default: +false+)
 
 +:check_compatibility+:: checks compatibility when saving
 
@@ -137,14 +137,11 @@ If a workbook is open and a workbook with the same name but in different path sh
 
 The methods +open+ and +new+ connect to workbooks opened outside of RobustExcelOle as well.
 
-Opening linked workbooks for EXCEL 2007 is supported
+Opening linked workbooks for EXCEL 2007 is supported. Changing linked, unsaved workbooks from read-only to read-write causes a query whether to save the changes. This case cannot be
+controlled (e.g. with help of some options) so far.
 
 Doing updating links seems to be dependent on calculation mode: updates happen, if the calcultion mode is automatic, and does not happen, if calculation mode is manual.
 
-Once we have a workbook, we can set some options, e.g.
-
-  workbook.for_this_workbook(visible: true, read_only: false)
-
 
 === Reopening a workbook
 
@@ -270,6 +267,8 @@ If the workbook is unsaved, use the option +if_unsaved+ as desribed above.
 
   workbook.writable = false, {if_unsaved: :forget}
 
+Changing from read-only to read-write for linked, unsaved workbooks is not being supported yet.
+
 === Checking whether the workbook is alive
 
 The method +alive?+ finds out whether the Excel workbook that is referenced by the Workbook object responds to methods. For example
@@ -277,4 +276,8 @@ The method +alive?+ finds out whether the Excel workbook that is referenced by t
   workbook.alive?
   # => true
 
+=== Setting options
+
+Once we have a workbook, we can set some options, e.g.
 
+  workbook.for_this_workbook(visible: true, read_only: false)

data/examples/modifying_sheets/example_access_sheets_and_cells.rb

@@ -7,7 +7,7 @@ require "fileutils"
 
 include RobustExcelOle
 
-Excel.close_all
+Excel.close_all(if_unsaved: :forget)
 begin
   dir = create_tmpdir
   simple_file = dir + 'workbook.xls'

data/examples/modifying_sheets/example_add_names.rb

@@ -26,7 +26,7 @@ begin
 
   def define_columns sheet, columns_ids
     puts "define_columns:"
-    first_column = sheet.range("A")
+    first_column = sheet.range("A:A")
     puts "first_column: #{first_column}"
 
     columns_ids.each_with_index do |id,idx|

data/examples/modifying_sheets/example_listobjects.rb

@@ -9,7 +9,7 @@ include RobustExcelOle
 
 using StringRefinement
 
-Excel.close_all
+Excel.close_all(if_unsaved: :forget)
 begin
   dir = create_tmpdir
   table_file = dir + 'workbook_listobjects.xlsx'
@@ -79,7 +79,7 @@ begin
   book.close(:if_unsaved => :forget)
   
 ensure
-  Excel.close_all
+  Excel.close_all(if_unsaved: forget)
   rm_tmp(dir)
 end
 

data/examples/modifying_sheets/example_ranges.rb

@@ -7,7 +7,7 @@ require "fileutils"
 
 include RobustExcelOle
 
-Excel.close_all
+Excel.close_all(if_unsaved: :forget)
 begin
   dir = create_tmpdir
   simple_file = dir + 'workbook.xls'

data/lib/robust_excel_ole/excel.rb

@@ -18,14 +18,18 @@ module User32
   typealias 'LPCSTR', 'const char*'
   typealias 'LPCWSTR', 'const wchar_t*'
   typealias 'UINT', 'unsigned int'
-  typealias 'HANDLE', 'void*'
   typealias 'ppvObject', 'void**'
   typealias 'DWORD', 'unsigned long'
   typealias 'LPDWORD', 'DWORD*'
+  typealias 'PDWORD_PTR', 'DWORD**'
+  typealias 'WPARAM', 'UINT*'
+  typealias 'LPARAM', 'INT*'
+  typealias 'LRESULT', 'DWORD'
   # Import C functions from loaded libraries and set them as module functions
   extern 'DWORD GetWindowThreadProcessId(HWND, LPDWORD)'
   extern 'HWND FindWindowExA(HWND, HWND, LPCSTR, LPCSTR)'
   extern 'DWORD SetForegroundWindow(HWND)'
+  extern 'LRESULT SendMessageTimeoutA(HWND, UINT, WPARAM, LPARAM, UINT, UINT, PDWORD_PTR)'
 end
 
 module Oleacc
@@ -68,6 +72,7 @@ module RobustExcelOle
     attr_reader :ole_excel
     attr_reader :properties
     attr_reader :address_tool
+    attr_reader :hwnd
 
     alias ole_object ole_excel
 
@@ -127,15 +132,16 @@ module RobustExcelOle
       end
       connected = (not ole_xl.nil?) && win32ole_excel.nil?
       ole_xl ||= WIN32OLE.new('Excel.Application')
-      hwnd = ole_xl.Hwnd
-      stored = hwnd2excel(hwnd)
+      hwnd_xl = ole_xl.Hwnd
+      stored = hwnd2excel(hwnd_xl)
       if stored && stored.alive?
         result = stored
       else
         result = super(options)
         result.instance_variable_set(:@ole_excel, ole_xl)
+        result.instance_variable_set(:@hwnd, hwnd_xl)
         WIN32OLE.const_load(ole_xl, RobustExcelOle) unless RobustExcelOle.const_defined?(:CONSTANTS)
-        @@hwnd2excel[hwnd] = WeakRef.new(result)
+        @@hwnd2excel[hwnd_xl] = WeakRef.new(result)
       end
       reused = options[:reuse] && stored && stored.alive? 
       options = { displayalerts: :if_visible, visible: false, screenupdating: true }.merge(options) unless reused || connected
@@ -159,6 +165,7 @@ module RobustExcelOle
         opts = {visible: false, displayalerts: :if_visible}.merge(
                {visible: @properties[:visible], displayalerts: @properties[:displayalerts]}).merge(opts)        
         @ole_excel = WIN32OLE.new('Excel.Application')
+        @hwnd = @ole_excel.Hwnd
         set_options(opts)
         if opts[:reopen_workbooks]
           workbook_class.books.each{ |book| book.open if !book.alive? && book.excel.alive? && book.excel == self }
@@ -531,13 +538,6 @@ module RobustExcelOle
       self
     end
 
-    # @private
-    def hwnd 
-      self.Hwnd
-    rescue
-      nil
-    end
-
     # @private
     def self.print_hwnd2excel
       @@hwnd2excel.each do |hwnd,wr_excel|
@@ -554,11 +554,15 @@ module RobustExcelOle
 
     # returns true, if the Excel instances responds to VBA methods, false otherwise
     def alive?
-      @ole_excel.Name
-      true
-    rescue
-      # trace $!.message
-      false
+      msg = 0x2008 
+      wparam = 0
+      lparam = 0
+      flags = 0x0000 # 0x0002
+      duration = 5000
+      lpdw_result_puffer = ' ' * 32
+      status = User32::SendMessageTimeoutA(hwnd, msg, wparam, lparam, flags, duration, lpdw_result_puffer)
+      result = lpdw_result_puffer.unpack('L')[0]
+      status != 0
     end
 
     # returns unsaved workbooks in known (not opened by user) Excel instances
@@ -589,6 +593,11 @@ module RobustExcelOle
       end
     end
 
+    # returns, whether the current Excel instance is visible
+    def visible
+      @ole_excel.Visible
+    end
+
     # makes the current Excel instance visible or invisible
     def visible= visible_value
       return if visible_value.nil?
@@ -596,6 +605,11 @@ module RobustExcelOle
       @ole_excel.DisplayAlerts = @properties[:visible] if @properties[:displayalerts] == :if_visible
     end
 
+    # returns, wheter DisplayAlerts is enabled
+    def displayalerts
+      @ole_excel.DisplayAlerts
+    end
+
     # enables DisplayAlerts in the current Excel instance
     def displayalerts= displayalerts_value
       return if displayalerts_value.nil?
@@ -726,7 +740,7 @@ module RobustExcelOle
 
     # @private
     def to_s            
-      "#<Excel: #{hwnd}#{ ("not alive" unless alive?)}>"
+      "#<Excel: #{hwnd}#{ (" not alive" unless alive?)}>"
     end
 
     # @private

data/lib/robust_excel_ole/general.rb

@@ -237,7 +237,7 @@ module General
     return filename unless filename[0,2] == "//"
     hostname = filename[0,filename[3,filename.length].index('/')+3]
     filename_wo_hostname = filename[hostname.length+1,filename.length]
-    abs_filename = absolute_path(filename_wo_hostname).tr('\\','/').tr('C:/','c$/')
+    abs_filename = absolute_path(filename_wo_hostname).tr('\\','/').sub('C:/','c$/')
     adapted_filename = hostname + "/" + abs_filename
     NetworkDrive.get_all_drives.each do |d|
       new_filename = filename.sub(/#{(Regexp.escape(d.network_name))}/i,d.drive_letter)

data/lib/robust_excel_ole/version.rb

@@ -1,3 +1,3 @@
 module RobustExcelOle
-  VERSION = "1.36"
+  VERSION = "1.37"
 end

data/lib/robust_excel_ole/workbook.rb

@@ -164,12 +164,12 @@ module RobustExcelOle
           raise ExcelREOError, "could not determine the Excel instance\n#{$!.message}"
         end
         @excel = excel_class.new(ole_excel)
-        filename = @ole_workbook.Fullname.tr('\\','/') 
+        file_name = @ole_workbook.Fullname.tr('\\','/') 
       else
-        filename = file_or_workbook
-        ensure_workbook(filename, opts)        
+        file_name = file_or_workbook
+        ensure_workbook(file_name, opts)        
       end      
-      apply_options(filename, opts)
+      apply_options(file_name, opts)
       store_myself
       if block_given?
         begin
@@ -244,7 +244,7 @@ module RobustExcelOle
     end
 
     # @private    
-    def ensure_workbook(filename, options)
+    def ensure_workbook(file_name, 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
@@ -252,35 +252,35 @@ module RobustExcelOle
         ((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)
+      file_name = @stored_filename ? @stored_filename : file_name 
+      manage_nonexisting_file(file_name,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?
+      @ole_workbook = workbooks.Item(File.basename(file_name)) rescue nil if @ole_workbook.nil?
       if @ole_workbook && alive?
         set_was_open options, true
-        #open_or_create_workbook(filename,options) if (!options[:read_only].nil?) && options[:read_only] 
-        manage_changing_readonly_mode(options) if (!options[:read_only].nil?) && options[:read_only] != @ole_workbook.ReadOnly
-        manage_blocking_or_unsaved_workbook(filename,options)
+        #open_or_create_workbook(file_name,options) if (!options[:read_only].nil?) && options[:read_only] 
+        manage_changing_readonly_mode(file_name, options) if (!options[:read_only].nil?) && options[:read_only] != @ole_workbook.ReadOnly
+        manage_blocking_or_unsaved_workbook(file_name,options)
       else
         if (excel_option.nil? || excel_option == :current) &&  
-          !(::CONNECT_JRUBY_BUG && filename[0] == '/')
-          connect(filename,options)
+          !(::CONNECT_JRUBY_BUG && file_name[0] == '/')
+          connect(file_name,options)
         else 
-          open_or_create_workbook(filename,options)
+          open_or_create_workbook(file_name,options)
         end
       end       
     end
 
   private
 
-    # applies options to workbook named with filename
-    def apply_options(filename, options)
+    # applies options to workbook named with file_name
+    def apply_options(file_name, options)
       # changing read-only mode      
       if (!options[:read_only].nil?) && options[:read_only] != @ole_workbook.ReadOnly
-        # ensure_workbook(filename, options) 
-        manage_changing_readonly_mode(options)
+        # ensure_workbook(file_name, options) 
+        manage_changing_readonly_mode(file_name, options)
       end
       retain_saved do
         self.visible = options[:force][:visible].nil? ? @excel.Visible : options[:force][:visible]
@@ -290,10 +290,10 @@ module RobustExcelOle
     end
 
     # connects to an unknown workbook
-    def connect(filename, options)   
+    def connect(file_name, options)   
       workbooks_number = excel_class.instance_count==0 ? 0 : excel_class.current.Workbooks.Count
       @ole_workbook = begin
-        WIN32OLE.connect(General.absolute_path(filename))
+        WIN32OLE.connect(General.absolute_path(file_name))
       rescue
         if $!.message =~ /moniker/
           raise WorkbookConnectingBlockingError, "some workbook is blocking when connecting"
@@ -314,21 +314,37 @@ module RobustExcelOle
       @excel = excel_class.new(ole_excel)
     end
 
-    def manage_changing_readonly_mode(options)
+    def manage_changing_readonly_mode(file_name, options)
       if !ole_workbook.Saved && options[:read_only]      
         manage_unsaved_workbook_when_changing_readonly_mode(options) 
       end
-      change_readonly_mode(options)
+      change_readonly_mode(file_name, options)
     end
 
-    def change_readonly_mode(options)
+    def change_readonly_mode(file_name, options)
       read_write_value = options[:read_only] ? RobustExcelOle::XlReadOnly : RobustExcelOle::XlReadWrite
       give_control_to_excel = !ole_workbook.Saved && options[:read_only] && 
                               (options[:if_unsaved] == :excel || options[:if_unsaved] == :alert)
       displayalerts = give_control_to_excel ? true : @excel.Displayalerts
+      # applying ChangeFileAccess to a linked unsaved workbook to change to read-write 
+      # causes a query
+      # how to check whether the workbook contains links?
+      #if options[:read_only]==false && !@ole_workbook.Saved # && @ole_workbook.LinkSources(RobustExcelOle::XlExcelLinks) # workbook linked
+      #  # @ole_workbook.Saved = true
+      #  raise WorkbookNotSaved, "linked workbook cannot be changed to read-write if it is unsaved"
+      #end
       @excel.with_displayalerts(displayalerts) {
-        @ole_workbook.ChangeFileAccess('Mode' => read_write_value)
+        begin
+          @ole_workbook.ChangeFileAccess('Mode' => read_write_value)
+      rescue WIN32OLERuntimeError
+        raise WorkbookReadOnly, "cannot change read-only mode"
+      end
       }
+      # managing Excel bug:
+      # if the workbook is linked, then ChangeFileAccess to read-write kills the workbook  
+      # if the linked workbook is unsaved, then ChangeFileAccess causes a query
+      # this query cannot be avoided or controlled so far (see above)
+      open_or_create_workbook(file_name, options) unless alive?
     end
 
     def manage_unsaved_workbook_when_changing_readonly_mode(options)
@@ -353,9 +369,9 @@ module RobustExcelOle
       end
     end
 
-    def manage_nonexisting_file(filename, options)   
-      return if File.exist?(filename)
-      abs_filename = General.absolute_path(filename)
+    def manage_nonexisting_file(file_name, options)   
+      return if File.exist?(file_name)
+      abs_filename = General.absolute_path(file_name)
       if options[:if_absent] == :create
         ensure_excel(options) unless @excel && @excel.alive?
         @excel.Workbooks.Add
@@ -363,7 +379,7 @@ module RobustExcelOle
         begin
           empty_ole_workbook.SaveAs(abs_filename)
         rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
-          raise FileNotFound, "could not save workbook with filename #{filename.inspect}"
+          raise FileNotFound, "could not save workbook with filename #{file_name.inspect}"
         end
       else
         raise FileNotFound, "file #{abs_filename.inspect} not found" +
@@ -371,90 +387,90 @@ module RobustExcelOle
       end
     end
 
-    def manage_blocking_or_unsaved_workbook(filename, options)
-      filename = General.absolute_path(filename)
-      filename = General.canonize(filename)
+    def manage_blocking_or_unsaved_workbook(file_name, options)
+      file_name = General.absolute_path(file_name)
+      file_name = General.canonize(file_name)
       previous_file = General.canonize(@ole_workbook.Fullname.gsub('\\','/'))
-      obstructed_by_other_book = (File.basename(filename) == File.basename(previous_file)) &&
-                                 (File.dirname(filename) != File.dirname(previous_file)) 
+      obstructed_by_other_book = (File.basename(file_name) == File.basename(previous_file)) &&
+                                 (File.dirname(file_name) != 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)        
+        manage_blocking_workbook(file_name,options)        
       else
         unless @ole_workbook.Saved
           # workbook open and writable, not obstructed by another workbook, but not saved
-          manage_unsaved_workbook(filename,options)
+          manage_unsaved_workbook(file_name,options)
         end
       end        
     end
 
-    def manage_blocking_workbook(filename, options)     
+    def manage_blocking_workbook(file_name, options)     
       blocked_filename = -> { General.canonize(@ole_workbook.Fullname.tr('\\','/')) }
       case options[:if_obstructed]
       when :raise
-        raise WorkbookBlocked, "can't open workbook #{filename},
+        raise WorkbookBlocked, "can't open workbook #{file_name},
         because it is being blocked by #{blocked_filename.call} with the same name in a different path." +
         "\nHint: Use the option :if_blocked with values :forget or :save,
          to allow automatic closing of the blocking workbook (without or with saving before, respectively),
          before reopening the workbook."
       when :forget
-        manage_forgetting_workbook(filename, options)       
+        manage_forgetting_workbook(file_name, options)       
       when :accept
         # do nothing
       when :save
-        manage_saving_workbook(filename, options)        
+        manage_saving_workbook(file_name, options)        
       when :close_if_saved
         if !@ole_workbook.Saved
           raise WorkbookBlocked, "workbook with the same name in a different path is unsaved: #{blocked_filename.call}" +
           "\nHint: Use the option if_blocked: :save to save the workbook"
         else
-          manage_forgetting_workbook(filename, options)
+          manage_forgetting_workbook(file_name, options)
         end
       when :new_excel
-        manage_new_excel(filename, options)        
+        manage_new_excel(file_name, options)        
       else
         raise OptionInvalid, ":if_blocked: invalid option: #{options[:if_obstructed].inspect}" +
         "\nHint: Valid values are :raise, :forget, :save, :close_if_saved, :new_excel"
       end
     end
 
-    def manage_unsaved_workbook(filename, options)
+    def manage_unsaved_workbook(file_name, options)
       case options[:if_unsaved]
       when :raise
-        raise WorkbookNotSaved, "workbook is already open but not saved: #{File.basename(filename).inspect}" +
+        raise WorkbookNotSaved, "workbook is already open but not saved: #{File.basename(file_name).inspect}" +
         "\nHint: Use the option :if_unsaved with values :forget to close the unsaved workbook, 
          :accept to let it open, or :save to save it, respectivly"
       when :forget
-        manage_forgetting_workbook(filename, options)
+        manage_forgetting_workbook(file_name, options)
       when :accept
         # do nothing
       when :save
-        manage_saving_workbook(filename, options)
+        manage_saving_workbook(file_name, options)
       when :alert, :excel
-        @excel.with_displayalerts(true) { open_or_create_workbook(filename,options) }
+        @excel.with_displayalerts(true) { open_or_create_workbook(file_name,options) }
       when :new_excel
-        manage_new_excel(filename, options)
+        manage_new_excel(file_name, options)
       else
         raise OptionInvalid, ":if_unsaved: invalid option: #{options[:if_unsaved].inspect}" +
         "\nHint: Valid values are :raise, :forget, :save, :accept, :alert, :excel, :new_excel"
       end
     end
 
-    def manage_forgetting_workbook(filename, options)
+    def manage_forgetting_workbook(file_name, options)
       @excel.with_displayalerts(false) { @ole_workbook.Close }
       @ole_workbook = nil
-      open_or_create_workbook(filename, options)
+      open_or_create_workbook(file_name, options)
     end
 
-    def manage_saving_workbook(filename, options)
+    def manage_saving_workbook(file_name, options)
       save unless @ole_workbook.Saved
-      manage_forgetting_workbook(filename, options) if options[:if_obstructed] == :save
+      manage_forgetting_workbook(file_name, options) if options[:if_obstructed] == :save
     end
 
-    def manage_new_excel(filename, options)
+    def manage_new_excel(file_name, options)
       @excel = excel_class.new(reuse: false)
       @ole_workbook = nil
-      open_or_create_workbook(filename, options)
+      open_or_create_workbook(file_name, options)
     end
 
     def explore_workbook_error(msg, want_change_readonly = nil)
@@ -473,10 +489,10 @@ module RobustExcelOle
       end
     end
 
-    def open_or_create_workbook(filename, options)
+    def open_or_create_workbook(file_name, options)
       return if @ole_workbook && options[:if_unsaved] != :alert && options[:if_unsaved] != :excel &&
                 (options[:read_only].nil? || options[:read_only]==@ole_workbook.ReadOnly )
-      abs_filename = General.absolute_path(filename)
+      abs_filename = General.absolute_path(file_name)
       workbooks = begin 
         @excel.Workbooks
       rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
@@ -493,7 +509,7 @@ module RobustExcelOle
       end
       # workaround for bug in Excel 2010: workbook.Open does not always return the workbook when given file name
       @ole_workbook = begin
-        workbooks.Item(File.basename(filename))
+        workbooks.Item(File.basename(file_name))
       rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
         raise UnexpectedREOError, "WIN32OLERuntimeError: #{msg.message}"
       end
@@ -536,8 +552,8 @@ module RobustExcelOle
     # creates, i.e., opens a new, empty workbook, and saves it under a given filename
     # @param [String] filename the filename under which the new workbook should be saved
     # @param [Hash] opts the options as in Workbook::open
-    def self.create(filename, opts = { })
-      open(filename, if_absent: :create)
+    def self.create(file_name, opts = { })
+      open(file_name, if_absent: :create)
     end
 
     # closes the workbook, if it is alive
@@ -656,11 +672,10 @@ module RobustExcelOle
         open_opts[:was_open] = nil  
         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.properties[:calculation]
-        #opts[:read_only] = !opts[:writable] unless (!opts[:read_only].nil? || opts[:writable].nil? || open_opts[:was_open])
+        was_writable = book.writable
         if (opts[:read_only].nil? && !opts[:writable].nil? && !open_opts[:was_open] && (was_saved || opts[:if_unsaved]==:save))
           opts[:read_only] = !opts[:writable]
         end
@@ -668,13 +683,14 @@ module RobustExcelOle
         yield book
       ensure
         if book && book.alive?
+          was_open = open_opts[:was_open]
           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))
+          if was_open && ((opts[:read_only] && was_writable) || (!opts[:read_only] && !was_writable))
             book.send :apply_options, file, opts.merge({read_only: !was_writable, 
                                             if_unsaved: (opts[:writable]==false ? :forget : :save)})
           end
-          was_open = open_opts[:was_open]
+          #was_open = open_opts[:was_open]
           if was_open
             book.visible = was_visible    
             book.CheckCompatibility = was_check_compatibility
@@ -1018,7 +1034,7 @@ module RobustExcelOle
 
     # returns the full file name of the workbook
     def filename
-      @filename ||= General.canonize(@ole_workbook.Fullname.tr('\\','/')) rescue nil
+      General.canonize(@ole_workbook.Fullname.tr('\\','/')) rescue nil
     end
 
     # @returns true, if the workbook is not in read-only mode
@@ -1040,7 +1056,7 @@ module RobustExcelOle
         options = options.merge(unsaved_opts) if unsaved_opts
         options = {:read_only => !writable_value}.merge(options)
         if options[:read_only] != @ole_workbook.ReadOnly
-          manage_changing_readonly_mode(options) 
+          manage_changing_readonly_mode(filename, options) 
           manage_unsaved_workbook(filename,options) if !@ole_workbook.Saved && unsaved_opts
         end
       end

data/spec/excel_spec.rb

@@ -75,6 +75,7 @@ module RobustExcelOle
       it "should set visible true" do
         @ole_excel.Visible.should be false
         excel = Excel.current(:visible => true)
+        excel.visible.should be true
         excel.Visible.should be true
       end
 
@@ -88,6 +89,7 @@ module RobustExcelOle
         @ole_excel.Visible.should be true
         excel = Excel.current(:visible => false)
         excel.Visible.should be false
+        excel.visible.should be false
       end
 
       it "should preserve displayalerts true" do
@@ -454,7 +456,9 @@ module RobustExcelOle
           @excel1.recreate
           @excel1.should be_a Excel
           @excel1.should be_alive
+          @excel1.visible.should be false
           @excel1.Visible.should be false
+          @excel1.displayalerts.should be false
           @excel1.DisplayAlerts.should be false
           @book1.should_not be_alive
           @book1.open
@@ -465,14 +469,20 @@ module RobustExcelOle
 
         it "should recreate an Excel instance with old visible and displayalerts values" do
           @excel1.visible = true
+          @excel1.Visible.should be true
+          @excel1.visible.should be true
           @excel1.displayalerts = true
+          @excel1.DisplayAlerts.should be true
+          @excel1.displayalerts.should be true
           @excel1.close
           @excel1.should_not be_alive
           @excel1.recreate
           @excel1.should be_a Excel
           @excel1.should be_alive
           @excel1.Visible.should be true
+          @excel1.visible.should be true
           @excel1.DisplayAlerts.should be true
+          @excel1.displayalerts.should be true
           @book1.open
           @book1.should be_alive
           @excel1.close

data/spec/workbook_specs/workbook_misc_spec.rb

@@ -27,7 +27,9 @@ describe Workbook do
     @another_simple_file = @dir + '/another_workbook.xls'
     @simple_file_xlsm = @dir + '/workbook.xls'
     @simple_file_xlsx = @dir + '/workbook.xlsx'
+    @simple_file_copy = @dir + '/workbook_copy.xls'
     @simple_file1 = @simple_file
+    @simple_file_copy1 = @simple_file_copy
   end
 
   after do
@@ -1083,7 +1085,7 @@ describe Workbook do
     context "with filename" do
 
       before do
-        @book = Workbook.open(@simple_file)
+        @book = Workbook.open(@simple_file1)
       end
 
       after do
@@ -1091,7 +1093,7 @@ describe Workbook do
       end
 
       it "should return full file name" do
-        @book.filename.should == @simple_file
+        @book.filename.should == @simple_file1
       end
 
       it "should return nil for dead book" do
@@ -1099,6 +1101,11 @@ describe Workbook do
         @book.filename.should == nil
       end
 
+      it "should return right filename when saved as another file name" do
+        @book.save_as(@simple_file_copy1)
+        @book.filename.should == @simple_file_copy1
+      end
+
     end
 
     context "with ==" do

data/spec/workbook_specs/workbook_open_spec.rb

@@ -370,11 +370,63 @@ describe Workbook do
         }.to raise_error(WorkbookLinked)
       end
 
-      it "should raise error when trying to change the read-only mode of the linked workbook" do
+      it "should change read-only mode of the linked workbook to read-only" do
         book2 = Workbook.open(@sub_file, :read_only => true)
         book2.ReadOnly.should be true
       end
+
+      it "should change read-only mode of the main workbook to read-only" do
+        book1 = Workbook.open(@main_file, :read_only => true)
+        book1.ReadOnly.should be true
+      end
+
     end
+
+    context "with read-only linked workbook" do
+
+      before do
+        @book1 = Workbook.open(@main_file, read_only: true, visible: true)
+      end
+
+      it "should change read-only mode of the main workbook to read-write" do
+        book2 = Workbook.open(@main_file, :read_only => false)
+        book2.ReadOnly.should be false
+      end
+
+      # here an query occurs whether to save the changes
+      # so far this case is not being controlled with help of options
+      it "should change read-only mode of the unsaved main workbook to read-write" do
+        book1.sheet(1)[1,1] = "foo"
+        book1 = Workbook.open(@main_file, :read_only => false)
+        book1.ReadOnly.should be false
+        book1.Saved.should be false
+      end
+
+      it "should change read-only mode of the main unsaved workbook to read-write" do
+        book2 = Workbook.open(@sub_file, :read_only => false)
+        book2.ReadOnly.should be false
+      end
+
+      it "should change read-only mode of the main workbook to read-write" do
+        book1 = Workbook.open(@main_file, :read_only => false)
+        book1.ReadOnly.should be false
+      end
+
+    end
+
+    context "with read-only" do
+
+      before do
+        @book1 = Workbook.open(@main_file, :read_only => true)
+      end
+
+      it "should change read-only mode from read-only to read-write" do
+        expect{
+          Workbook.open(@main_file, :read_only => false)
+        }.to_not raise_error
+      end
+    end
+
   end
 
   describe "basic tests with xlsx-workbooks" do
@@ -3165,9 +3217,11 @@ describe Workbook do
       before do
         @new_book = Workbook.open(@simple_file)
       end
+
       after do
         @new_book.close
       end
+      
       it "should provide the excel instance of the book" do
         excel = @new_book.excel
         excel.class.should == Excel
@@ -3329,6 +3383,7 @@ describe Workbook do
       end
 
       it "should open xlsx file" do
+
         book = Workbook.open(@simple_file_xlsx, :visible => true)
         book.close
       end
@@ -3380,4 +3435,5 @@ describe Workbook do
       end
     end
   end  
-end
+end
+

data/spec/workbook_specs/workbook_unobtr_spec.rb

@@ -311,6 +311,24 @@ describe Workbook do
 
     context "with no books" do
 
+      it "should open the linked workbook" do
+        Workbook.unobtrusively(@sub_file, :writable => true) do |book|            
+          book.ReadOnly.should be false
+          book.filename.should == @sub_file
+        end
+        Excel.current.workbooks.should == [] 
+      end
+
+      it "should open the workbook and its linked workbook" do
+        Workbook.unobtrusively(@main_file, :writable => true) do |book|            
+          book.ReadOnly.should be false
+          book.filename.should == @main_file
+          book.excel.workbooks.map{|b| b.filename}.should == [@main_file, @sub_file]
+        end
+        Excel.current.workbooks.map{|b| b.filename}.should  == [@sub_file] 
+      end
+
+
       it "should open the linked workbook in read-only" do
         Workbook.unobtrusively(@sub_file, :writable => false) do |book|            
           book.ReadOnly.should be true
@@ -323,14 +341,14 @@ describe Workbook do
         Workbook.unobtrusively(@main_file, :writable => false) do |book|            
           book.ReadOnly.should be true
           book.filename.should == @main_file
-          book.excel.workbooks.map{|b| b.filename}.should == [@sub_file, @main_file]
+          book.excel.workbooks.map{|b| b.filename}.should == [@main_file, @sub_file]
         end
         Excel.current.workbooks.map{|b| b.filename}.should  == [@sub_file] 
       end
 
       it "should not write the linked workbook and close it" do
-        Workbook.unobtrusively(@sub_file, :writable => false) do |book|            
-          book.ReadOnly.should be true
+        Workbook.unobtrusively(@sub_file) do |book|            
+          book.ReadOnly.should be false
           book.filename.should == @sub_file
           @old_value = book.sheet(1)[1,1]
           book.sheet(1)[1,1] = book.sheet(1)[1,1] == "foo" ? "bar" : "foo" 
@@ -339,8 +357,8 @@ describe Workbook do
       end
 
       it "should not write the main workbook and close the linked file as well" do
-        Workbook.unobtrusively(@main_file, :writable => false) do |book|            
-          book.ReadOnly.should be true
+        Workbook.unobtrusively(@main_file) do |book|            
+          book.ReadOnly.should be false
           book.filename.should == @main_file
           @old_value = book.sheet(1)[1,1]
           book.sheet(1)[1,1] = book.sheet(1)[1,1] == "foo" ? "bar" : "foo" 
@@ -362,7 +380,7 @@ describe Workbook do
         end
       end
       
-      it "should force to read-only" do
+      it "should raise error, when forcing the linked workbook to read-only" do
         expect{
           Workbook.unobtrusively(@sub_file, :read_only => true) do
           end
@@ -946,20 +964,6 @@ describe Workbook do
           }.to raise_error(WorkbookNotSaved)
         end
 
-=begin
-        it "should remain writable" do
-          Workbook.unobtrusively(@unsaved_file, :read_only => true, :if_unsaved => :save) do |book|
-            book.saved.should be true
-            book.visible.should be true
-            book.writable.should be false
-          end
-          ole_wb = WIN32OLE.connect(@abs_filename)
-          ole_wb.Saved.should be false
-          @ole_e1.Visible.should be true
-          ole_wb.ReadOnly.should be false
-        end
-=end
-
         it "should remain unsaved when modifying" do
           Workbook.unobtrusively(@unsaved_file) do |book|
             book.sheet(1)[1,1] = "bar" #book.sheet(1)[1,1] == "foo" ? "bar" : "foo"
@@ -1386,15 +1390,13 @@ describe Workbook do
         end
 
         it "should force to read-only" do
-          expect{
-            Workbook.unobtrusively(@simple_file1, :if_unsaved => :forget, :read_only => true) do |book|            
-              book.ReadOnly.should be true
-              book.should == @book
-              book.filename.should == @book.filename
-              book.excel.should == @book.excel
-              book.sheet(1)[1,1] = book.sheet(1)[1,1] == "foo" ? "bar" : "foo" 
-            end
-            }.to raise_error(WorkbookReadOnly)
+          Workbook.unobtrusively(@simple_file1, :if_unsaved => :forget, :read_only => true) do |book|            
+            book.ReadOnly.should be true
+            book.should == @book
+            book.filename.should == @book.filename
+            book.excel.should == @book.excel
+            book.sheet(1)[1,1] = book.sheet(1)[1,1] == "foo" ? "bar" : "foo" 
+          end
         end
 
 
@@ -1696,9 +1698,18 @@ describe Workbook do
         end
 
         it "should open as read-only" do
-          expect{
-            Workbook.unobtrusively(@simple_file1, :if_unsaved => :accept, :read_only => false, :writable => false)
-          }.to raise_error(OptionInvalid)
+          Workbook.unobtrusively(@simple_file1, :if_unsaved => :accept, :read_only => false, :writable => false) do |book|
+            book.Readonly.should be false
+            book.Saved.should be false
+            book.sheet(1)[1,1].should == @old_value
+            book.sheet(1)[1,1] = book.sheet(1)[1,1] == "foo" ? "bar" : "foo"
+          end
+          @book.ReadOnly.should be true
+          @book.Saved.should be false
+          @book.sheet(1)[1,1].should_not == @old_value
+          @book.close(if_unsaved: :forget)
+          book2 = Workbook.open(@simple_file1)
+          book2.sheet(1)[1,1].should_not == @old_value
         end
 
         it "should remain read-only and not write, even with :writable => true" do

data/spec/worksheet_spec.rb

@@ -315,13 +315,13 @@ describe Worksheet do
       it "should raise an error if name not defined" do
         expect {
           @sheet1.namevalue_global("foo")
-        }.to raise_error(NameNotFound, /name "foo" not in/)
+        }.to raise_error(NameNotFound, /cannot find name "foo"/)
       end
 
       it "should raise an error of coordinates are given instead of a defined name" do
         expect {
           @sheet1.namevalue_global("A1")
-        }.to raise_error(NameNotFound, /name "A1" not in/)
+        }.to raise_error(NameNotFound, /cannot find name "A1"/)
       end
 
       it "should return default value for a range with empty contents" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: robust_excel_ole
 version: !ruby/object:Gem::Version
-  version: '1.36'
+  version: '1.37'
 platform: ruby
 authors:
 - traths
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-29 00:00:00.000000000 Z
+date: 2021-11-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry