robust_excel_ole 0.5 → 0.5.1

data/Changelog

@@ -1,19 +1,32 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
+## [0.5.1] - 2016-18-06
+
+### Added
+- Book#open :force_excel => :active
+
+### Changed
+- Book: open: :default_excel, :force_excel => :active, (:reuse as alias), bug fix in :default
+		unobtrusively: :if_closed => :active (:reuse as alias)
+- Excel: with_calculation: bug fix
+- Sheet: [], []= broader implementation
+
+
 ## [0.5.0] - 2016-31-05
 
 ### Added
 - Book: sheet, add_empty_sheet, copy_sheet
 		rangeval, set_rangeval, nameval, set_nameval
 		open: option check_compatibility
-- Sheet: last_sheet, first_sheet, rangeval, nameval
+- Sheet: last_sheet, first_sheet, rangeval, nameval, [], []=
 - Excel: with_calculaiton, rangeval, set_rangeval, nameval, set_nameval, [], []=
 
 ### Changed
 - Book: book.sheet(<sheet_name>) replaces book[<sheet-name>]
         add_or_copy_sheet replaces add_sheet
         name_val, set_name_val replaces n_value, set_n_value
+        [], []= via nameval, set_nameval
 
        
 ## [0.4] - 2016-03-16

data/README.rdoc

@@ -43,14 +43,28 @@ Options are
   +:default_excel+, +:force_excel+, +:if_absent+, +:if_unsaved+, +:if_obstructed+, 
   +:read_only+, +:check_compatibility, +:visible+, +:displayalerts+. 
 
-Valid values for +:default_excel+ are +:reuse+, +:new+ or some Excel instance, for +:force_excel+ : +:new+ or some Excel instance, for +:if_unsaved+ : +:raise+, +:accept+, +:forget+, +:alert+ and +:new_excel+, for +:if_obstructed+ : +:raise+, +:save+, +:close_if_saved+, +:forget+, +:alert+ and +:new_excel+ , for +:if_absent+ : +:raise+ and +:create+.
+Valid values for +:default_excel+ are +:active+ (or +:reuse+), +:new+ or some Excel instance, for +:force_excel+ : +:active (or +:reuse+), +:new+ or some Excel instance, for +:if_unsaved+ : +:raise+, +:accept+, +:forget+, +:alert+ and +:new_excel+, for +:if_obstructed+ : +:raise+, +:save+, +:close_if_saved+, +:forget+, +:alert+ and +:new_excel+ , for +:if_absent+ : +:raise+ and +:create+.
 
 Here are a few examples:
 
-Opening a workbook in the Excel instance where it was opened before, or opening the workbook in a new Excel instance if it was not opened before.
+Opening a workbook in the Excel instance where it was opened before most recently, if it was opened before and this Excel instance is alive. Otherwise opening it in a running Excel, if it exists, or in a new Excel.
+
+Opening a workbook in the Excel instance where it was opened before most recently, if it was opened before and this Excel instance is alive. Otherwise opening it in a new Excel instance.
 
   book = Book.open('workbook.xls', :default_excel => :new)
 
+Opening a workbook in the Excel instance where it was opened before most recently, if it was opened before and this Excel instance is alive. Otherwise opening it in a given Excel instance.
+
+  book = Book.open('workbook.xls', :default_excel => excel1)
+
+Opening a workbook in a new Excel instance, no matter if the workbook was opened before and if the old Excel instance is alive.
+
+  book = Book.open('workbook.xls', :force_excel => :new)
+
+Opening a workbook in a given Excel instance, no matter if the workbook was opened before and if the old Excel instance is alive.
+
+  book = Book.open('workbook.xls', :force_excel => excel1)
+
 Opening a workbook in a new Excel instance and make it visible.
 
   book = Book.open('workbook.xls', :force_excel => :new, :visible => true)
@@ -123,11 +137,11 @@ If a workbook is blocking the workbook that should be saved, then the former one
 
 The method +unobtrusively+ enables the user to read or modify a workbook, no matter if it is open in some Excel instance, if it is saved or unsaved, and if it is writable or not. When opening a workbook unobtrusively, its status remains unchanged. This status includes, whether the workbook is opened or closed, saved or unsaved, readonly or writable. 
 
-Some options determine the Excel instance in which a closed workbook is opened. The options +:reuse (default) indicates that the closed workbook is opened in the Excel instance where the workbooks is opened, if such an Excel instance exists, otherwise that another Excel instance is reused. The option +:hidden+ provokes that the closed workbook is opened in a separate Excel instance that is not visible and has no DisplayAlerts. Any following closed workbook would be opened in this Excel instance as well when using this option. Moreover, an Excel instance can be given directly where to open the closed workbook.
+Some options determine the Excel instance in which a closed workbook is opened. The options +:active+ (or +:reuse+) (default) indicates that the closed workbook is opened in the Excel instance where the workbooks is opened, if such an Excel instance exists, otherwise that another Excel instance is reused. The option +:hidden+ provokes that the closed workbook is opened in a separate Excel instance that is not visible and has no DisplayAlerts. Any following closed workbook would be opened in this Excel instance as well when using this option. Moreover, an Excel instance can be given directly where to open the closed workbook.
 
 Further options are +:read_only+, +:readonly_excel+, and +:keep_open. The option +:readonly_excel+ chooses whether a book that is opened in read only mode. If the workbook is opened as read only, then the option +:readonly_excel+ determines whether to close the workbook and open it as writable in the Excel instance where it was open so far, or to open it as writable in another running Excel instance, if such an instance exists, or to open it in a new Excel instance. Moreover, there are the options +:visible+, +:displayalerts+ and +:check_compatiblity.
 
-  Book.unobtrusively('workbook.xls', :reuse, :read_only => false, :keep_open => false) do |book|
+  Book.unobtrusively('workbook.xls', :active, :read_only => false, :keep_open => false) do |book|
     # some modification
     sheet = book[0]
     sheet[1,1] = "c" 

data/README_detail.rdoc

@@ -41,8 +41,9 @@ The semantics is similar to, e.g., +File.open+.
 
 Options are the following:
 
-+:default_excel+::   open the workbook in the Excel instance where it was opened before if the book was once open, otherwise in a new or already used Excel instance (default: +reuse+)
-+:force_excel+::     open the workbook in a new or given Excel instance (defaut: +:new+)
++:default_excel+::   open the workbook in the Excel instance where it was opened before most recently,
+if the book was opened before and this Excel instance is alive. Otherwise open it in the active (+:active+ or +:reuse+), a new (+:new+) or a given Excel instance (default: +reuse+)
++:force_excel+::     open the workbook in the active, a new or given Excel instance 
 +:if_absent+::       specify behaviour if the workbook with the given file name does not exist if the workbook does not exist (default: +create+)
 +:if_unsaved+::      specify behaviour if the workbook was unsaved (default: +new_excel+)
 +:if_obstructed+::   specidy behaviour if the workbook is blocked by another book (default: +new_excel+)
@@ -53,15 +54,16 @@ Options are the following:
 
 The option +:defaut_excel+  :
 
-If the workbook was open before, then open it in the Excel instance where it was open before. If the workbook cannot be reopened, then
+If the workbook was open before, then open it in the Excel instance where it was open before most recently. If the workbook cannot be reopened, i.e., the book was not opened before, or the Excel is not alive anymore,
+then
 
-+:reuse+:: Connect to a running Excel, if it exists, otherwise open a new Excel.
++:active+ (or :reuse+:): Connect to a running Excel, if it exists, otherwise open a new Excel.
 +:new+:: Open in a new Excel.
 [instance]:: Open in a given Excel instance.
 
 The option +:force_excel  :
 
-No matter if the workbook was open before,
+No matter if the workbook was open before, or the Excel instance is alive
 
 +:new+:: Open in a new Excel instance.
 [instance]:: Open in a given Excel instance.
@@ -95,6 +97,41 @@ If a workbook is open and a new workbook with same name and a different path is
 
 The values :displayalerts and :visible are reached to the class Excel that controls opening and closing Excel instances.
 
+Here are a few examples:
+
+Opening a workbook in the Excel instance where it was opened before most recently, if it was opened before and this Excel instance is alive. Otherwise opening it in a running Excel, if it exists, or in a new Excel.
+
+Opening a workbook in the Excel instance where it was opened before most recently, if it was opened before and this Excel instance is alive. Otherwise opening it in a new Excel instance.
+
+  book = Book.open('workbook.xls', :default_excel => :new)
+
+Opening a workbook in the Excel instance where it was opened before most recently, if it was opened before and this Excel instance is alive. Otherwise opening it in a given Excel instance.
+
+  book = Book.open('workbook.xls', :default_excel => excel1)
+
+Opening a workbook in a new Excel instance, no matter if the workbook was opened before and if the old Excel instance is alive.
+
+  book = Book.open('workbook.xls', :force_excel => :new)
+
+Opening a workbook in a given Excel instance, no matter if the workbook was opened before and if the old Excel instance is alive.
+
+  book = Book.open('workbook.xls', :force_excel => excel1)
+
+Opening a workbook in a new Excel instance and make it visible.
+
+  book = Book.open('workbook.xls', :force_excel => :new, :visible => true)
+
+If a workbook contains unsaved changes and a workbook with the same filename shall be opened, then Excel gives an alert message.
+The option +:if_unsaved+ manages this case. For example, +:if_unsaved+ => +:accept+  indicates that the workbook remains open, but no error is raised, i.e. the program can continue.
+
+  book = Book.open('workbook.xls', :if_unsaved => :accept)
+
+If a workbook is open and a workbook with the same name but in different path shall be opened, then the first workbook blocks opening the other workbook. The option +:if_obstructed+ handles this situation. For example, +:if_obstructed+ => +:forget+ causes the old workbook to close and to open the new workbook.
+
+  book = Book.open('path/workbook.xls', :if_obstructed => :forget)
+
+Opening linked workbooks for EXCEL 2007 is supported
+
 === Closing a workbook.
 
 Simple close.
@@ -176,11 +213,11 @@ If a workbook is blocking the workbook that should be saved, then the former one
 
 The method +unobtrusively+ enables the user to read or modify a workbook, no matter if it is open in some Excel instance, if it is saved or unsaved, and if it is writable or not. When opening a workbook unobtrusively, its status remains unchanged. This status includes, whether the workbook is opened or closed, saved or unsaved, readonly or writable. 
 
-One option chooses the Excel instance in which a closed workbook is opened. The options +:reuse (default) indicates that the closed workbook is opened in the Excel instance of the workbook, if it exists, or that another Excel instance is reused. The option +:hidden+ provokes that the closed workbook is opened in a separate Excel instance that is not visible and has no DisplayAlerts. Any following closed workbook would be opened in this Excel instance as well when using this option. Moreover, an Excel instance can be given directly where to open the closed workbook.
+One option chooses the Excel instance in which a closed workbook is opened. The options +:active+ (or +:reuse) (default) indicates that the closed workbook is opened in the Excel instance of the workbook, if it exists, or that another Excel instance is reused. The option +:hidden+ provokes that the closed workbook is opened in a separate Excel instance that is not visible and has no DisplayAlerts. Any following closed workbook would be opened in this Excel instance as well when using this option. Moreover, an Excel instance can be given directly where to open the closed workbook.
 
 Options are the following:
 
-+:reuse+:: (default) : open a closed workbook in the Excel instance of the workbook, if it exists, otherwise reuse another Excel
++:active (or +:reuse+:): (default) : open a closed workbook in the Excel instance of the workbook, if it exists, otherwise reuse another Excel
 +:hidden+::          : open a closed workbook in one separate Excel instance that is not visible and has no displayalerts
 <excel-instance> : open a closed workbooks in the given Excel instance
                
@@ -413,6 +450,7 @@ Creating a new Excel.
   excel1 = Excel.create
 
 Getting a running Excel instance and reusing it.
+Connecting to the first opened Excel instance. If this Excel instance is being closed, then Excel creates a new Excel instance that has the same Hwnd
 
   excel2 = Excel.current
 

data/lib/robust_excel_ole/book.rb

@@ -15,9 +15,8 @@ module RobustExcelOle
     alias ole_object ole_workbook
 
       DEFAULT_OPEN_OPTS = { 
-        :excel => :reuse,
-        :default_excel => :reuse,
-        :if_lockraiseed => :readonly,       
+        :excel => :active,
+        :default_excel => :active,      
         :if_unsaved    => :raise,
         :if_obstructed => :raise,
         :if_absent     => :raise,
@@ -30,8 +29,8 @@ module RobustExcelOle
       # opens a workbook.
       # @param [String] file the file name
       # @param [Hash] opts the options
-      # @option opts [Variant] :default_excel  :reuse (default), :new, or <excel-instance>     
-      # @option opts [Variant] :force_excel    :new (default), or <excel-instance>
+      # @option opts [Variant] :default_excel  :active (default), :new, or <excel-instance>     
+      # @option opts [Variant] :force_excel    :active, :new, or <excel-instance>
       # @option opts [Symbol]  :if_unsaved     :raise (default), :forget, :accept, :alert, :excel, or :new_excel
       # @option opts [Symbol]  :if_obstructed  :raise (default), :forget, :save, :close_if_saved, or _new_excel
       # @option opts [Symbol]  :if_absent      :raise (default), or :create
@@ -39,15 +38,17 @@ module RobustExcelOle
       # @option opts [Boolean] :displayalerts  true, or false (default)
       # @option opts [Boolean] :visible        true, or false (default) 
       # options: 
-      # :default_excel   if the workbook was already open in an Excel instance, then open it there.
+      # :default_excel   if the workbook was already open in an Excel instance, then open it in that Excel instance,
+      #                  where it was opened most recently
       #                  Otherwise, i.e. if the workbook was not open before or the Excel instance is not alive
-      #                   :reuse           -> connects to a (the first opened) running Excel instance,
+      #                   :active or :reuse -> connects to a running (the first opened) Excel instance,
       #                                        excluding the hidden Excel instance, if it exists,
       #                                       otherwise opens in a new Excel instance.
       #                   :new             -> opens in a new Excel instance
       #                   <excel-instance> -> opens in the given Excel instance
       # :force_excel     no matter whether the workbook was already open
-      #                   :new             -> opens in a new Excel instance
+      #                   :new             -> connects to a running (the first opened) Excel instance
+      #                   :active or :reuse   -> opens in the active Excel instance
       #                   <excel-instance> -> opens in the given Excel instance
       # :if_unsaved     if an unsaved workbook with the same name is open, then
       #                  :raise               -> raises an exception
@@ -73,14 +74,19 @@ module RobustExcelOle
       # @return [Book] a workbook
       def open(file, opts={ }, &block)
         options = DEFAULT_OPEN_OPTS.merge(opts)
+        options[:default_excel] = :active if options[:default_excel] == :reuse
+        options[:force_excel] = :active if options[:force_excel] == :reuse
         book = nil
-        if (not (options[:force_excel] == :new && (not options[:if_locked] == :take_writable)))
+        if (not (options[:force_excel] == :new))
           # if readonly is true, then prefer a book that is given in force_excel if this option is set
+          forced_excel = if options[:force_excel]
+            options[:force_excel] == :active ? excel_class.new(:reuse => true) : excel_of(options[:force_excel])
+          end
           book = bookstore.fetch(file, 
                   :prefer_writable => (not options[:read_only]), 
-                  :prefer_excel    => (options[:read_only] ? excel_of(options[:force_excel]) : nil)) rescue nil
+                  :prefer_excel    => (options[:read_only] ? forced_excel : nil)) rescue nil
           if book
-            if (((not options[:force_excel]) || (excel_of(options[:force_excel]) == book.excel)) &&
+            if (((not options[:force_excel]) || (forced_excel == book.excel)) &&
                  (not (book.alive? && (not book.saved) && (not options[:if_unsaved] == :accept))))
               book.options = DEFAULT_OPEN_OPTS.merge(opts)
               book.ensure_excel(options) unless book.excel.alive?
@@ -122,8 +128,7 @@ module RobustExcelOle
     # @option opts [Symbol] see above
     # @return [Book] a workbook
     def initialize(file_or_workbook, opts={ }, &block)
-      options = DEFAULT_OPEN_OPTS.merge(opts)
-      options[:excel] = options[:force_excel] ? options[:force_excel] : options[:default_excel]
+      options = DEFAULT_OPEN_OPTS.merge(opts)      
       if file_or_workbook.is_a? WIN32OLE
         workbook = file_or_workbook
         @ole_workbook = workbook        
@@ -170,7 +175,7 @@ module RobustExcelOle
         begin
           object.excel
         rescue
-          raise ExcelErrorOpen, "given object is neither an Excel, a Book, nor a Win32ole"
+          raise ExcelErrorOpen, "given object is neither an Excel, a Workbook, nor a Win32ole"
         end
       end
       #rescue
@@ -181,27 +186,13 @@ module RobustExcelOle
 
     def ensure_excel(options)   # :nodoc: #
       return if @excel && @excel.alive?
-      if options[:excel] == :reuse
-        @excel = excel_class.new(:reuse => true)
-      end
-      excel_options = nil
-      if @excel 
-        dead_or_recycled = begin
-          (not @excel.alive?)
-        rescue WeakRef::RefError => msg
-          true
-        end
-      end
-      if (not @excel) || dead_or_recycled
-        if options[:excel] == :new || dead_or_recycled
-          excel_options = {:displayalerts => false, :visible => false}.merge(options)
-          excel_options[:reuse] = false
-          @excel = excel_class.new(excel_options)
-        else 
-          @excel = self.class.excel_of(options[:excel])
-        end
-      end
-      apply_options(options) unless excel_options
+      options[:excel] = options[:force_excel] ? options[:force_excel] : options[:default_excel]
+      options[:excel] = :active if options[:excel == :reuse]
+      excel_options = {:displayalerts => false, :visible => false}.merge(options)
+      excel_options[:reuse] = (options[:excel] == :active) 
+      @excel = self.class.excel_of(options[:excel]) unless (options[:excel] == :active || options[:excel] == :new)
+      @excel = excel_class.new(excel_options) unless (@excel && @excel.alive?)
+      apply_options unless excel_options
     end
 
     def ensure_workbook(file, options)     # :nodoc: #
@@ -394,7 +385,7 @@ module RobustExcelOle
     # @param [String] file        the file name
     # @param [Hash]   if_closed   an option
     # @param [Hash]   opts        the options
-    # @option opts [Variant] :if_closed  :reuse (default), :hidden or a Excel instance
+    # @option opts [Variant] :if_closed  :active or :reuse (default), :hidden or a Excel instance
     # @option opts [Boolean] :read_only whether the file is opened for read-only
     # @option opts [Boolean] :readonly_excel behaviour when workbook is opened read-only and shall be modified
     # @option opts [Boolean] :keep_open whether the workbook shall be kept open after unobtrusively opening
@@ -402,8 +393,8 @@ module RobustExcelOle
     # @option opts [Boolean] :visible        true, or false (default) 
     #  options: 
     #   :if_closed :   if the workbook is closed, then open it in
-    #                    :reuse  -> the Excel instance of the workbook, if it exists, 
-    #                               reuse another Excel, otherwise          
+    #                    :active or :reuse -> the Excel instance of the workbook, if it exists, 
+    #                                         reuse another Excel, otherwise          
     #                    :hidden -> a separate Excel instance that is not visible and has no displayaslerts
     #                    <excel-instance> -> the given Excel instance
     #  :read_only        : opens the workbook unobtrusively for reading only  (default: false)
@@ -420,7 +411,8 @@ module RobustExcelOle
         opts = if_closed
         if_closed = nil
       end
-      if_closed = :reuse unless if_closed
+      if_closed = :active if if_closed == :reuse
+      if_closed = :active unless if_closed
       options = {
         :read_only => false,
         :readonly_excel => false,
@@ -443,7 +435,7 @@ module RobustExcelOle
         book = 
           if was_not_alive_or_nil 
             case if_closed
-            when :reuse
+            when :active
               open(file, :read_only => options[:read_only])
             when :hidden 
               open(file, :force_excel => bookstore.hidden_excel, :read_only => options[:read_only])
@@ -582,9 +574,9 @@ module RobustExcelOle
         dirname, basename = File.split(file)
         file_format =
           case File.extname(basename)
-            when '.xls' : RobustExcelOle::XlExcel8
-            when '.xlsx': RobustExcelOle::XlOpenXMLWorkbook
-            when '.xlsm': RobustExcelOle::XlOpenXMLWorkbookMacroEnabled
+            when '.xls' ; RobustExcelOle::XlExcel8
+            when '.xlsx'; RobustExcelOle::XlOpenXMLWorkbook
+            when '.xlsm'; RobustExcelOle::XlOpenXMLWorkbookMacroEnabled
           end
         @ole_workbook.SaveAs(General::absolute_path(file), file_format)
         bookstore.store(self)

data/lib/robust_excel_ole/excel.rb

@@ -18,7 +18,9 @@ module RobustExcelOle
       new(:reuse => false)
     end
 
-    # uses the current Excel instance (connects), if such a running Excel instance exists
+    # returns (connects to) the current Excel instance, if such a running Excel instance exists    
+    #   more specific: connects to the first opened Excel instance
+    #   if this Excel instance is being closed, then Excel creates a new Excel instance that has the same Hwnd
     # creates a new one, otherwise 
     # @return [Excel] an Excel instance
     def self.current
@@ -26,7 +28,7 @@ module RobustExcelOle
     end
 
     # returns an Excel instance  
-    # given a WIN32OLE object representing an Excel instance, or a Hash representing options:
+    # given a WIN32OLE object representing an Excel instance, or a Hash representing options
     # @param [Hash] options the options
     # @option options [Boolean] :reuse  
     # @option options [Boolean] :displayalerts 
@@ -107,11 +109,11 @@ module RobustExcelOle
 
   private
     
-    # returns an Excel instance to which one 'connect' was possible
+    # returns (connects to) a running Excel instance
+    # connects to the first opened Excel instance
+    # if this Excel instance is being closed, then Excel creates a new Excel instance that has the same Hwnd
     def self.current_excel   # :nodoc: #
-      #p "current_excel:"
       result = WIN32OLE.connect('Excel.Application') rescue nil
-      #p "result: #{result}"
       if result
         begin
           result.Visible    # send any method, just to see if it responds
@@ -120,7 +122,6 @@ module RobustExcelOle
           return nil
         end
       end
-      #p "result: #{result}"
       result
     end
 
@@ -324,7 +325,6 @@ module RobustExcelOle
       end
       @@hwnd2excel.delete(excel_hwnd)      
       if options[:hard] then
-        Excel.free_all_ole_objects
         process_id = Win32API.new("user32", "GetWindowThreadProcessId", ["I","P"], "I")
         pid_puffer = " " * 32
         process_id.call(excel_hwnd, pid_puffer)
@@ -501,8 +501,7 @@ module RobustExcelOle
       @visible = @ole_excel.Visible
     end    
 
-    # sets calculation mode
-    # does not reset the calculation mode after block
+    # sets calculation mode in a block
     def with_calculation(calculation_mode = :automatic)
       if @ole_excel.Workbooks.Count > 0
         old_calculation_mode = @ole_excel.Calculation
@@ -512,12 +511,20 @@ module RobustExcelOle
         begin
           yield self
         ensure
-          #@ole_excel.Calculation = old_calculation_mode if alive?
-          #@ole_excel.CalculateBeforeSave = old_calculation_before_save_mode if alive?
+          @ole_excel.Calculation = old_calculation_mode if alive?
+          @ole_excel.CalculateBeforeSave = old_calculation_before_save_mode if alive?
         end
       end
     end
 
+    # sets calculation mode
+    def set_calculation(calculation_mode = :automatic)
+      if @ole_excel.Workbooks.Count > 0
+        @ole_excel.Calculation = calculation_mode == :automatic ? XlCalculationAutomatic : XlCalculationManual
+        @ole_excel.CalculateBeforeSave = (calculation_mode == :automatic)
+      end
+    end
+
     # returns the value of a range
     # @param [String] name the name of a range
     # @returns [Variant] the value of the range

data/lib/robust_excel_ole/sheet.rb

@@ -48,7 +48,10 @@ module RobustExcelOle
         @cells[yx] = RobustExcelOle::Cell.new(@worksheet.Cells.Item(y, x))
       else
         name = p1
-        nameval(name)
+        value = nameval(name) rescue nil
+        value = book_class.new(self.Parent).nameval(name) rescue nil unless value
+        value = rangeval(name) unless value
+        value
       end
     end
 
@@ -60,7 +63,15 @@ module RobustExcelOle
         @worksheet.Cells.Item(y, x).Value = value
       else
         name, value = p1, p2
-        set_nameval(name, value)
+        begin
+          set_nameval(name, value) 
+        rescue SheetError
+          begin
+            book_class.new(self.Parent).set_nameval(name, value)
+          rescue ExcelError
+            set_rangeval(name, value)
+          end
+        end
       end
     end
 
@@ -116,30 +127,30 @@ module RobustExcelOle
     # @param [String] name  the name of a range
     # @param [Hash]   opts  the options
     # @option opts [Variant] :default default value (default: nil)
-    # @raise SheetError if name is not defined or if value of the range cannot be evaluated
+    # @raise SheetError if name is not defined or if value of the range cannot be evaluated  
     def nameval(name, opts = {:default => nil})
       begin
         name_obj = self.Names.Item(name)
       rescue WIN32OLERuntimeError
+        return opts[:default] if opts[:default]
+        raise SheetError, "name #{name.inspect} not in #{self.Name}"
+      end
+      begin
+        value = name_obj.RefersToRange.Value
+      rescue  WIN32OLERuntimeError
         begin
-          value = self.Evaluate(name)
+          value = self.Evaluate(name_obj.Name)
         rescue WIN32OLERuntimeError
           return opts[:default] if opts[:default]
-          raise SheetError, "cannot find or evaluate name #{name.inspect} in #{self.Name}"
-        end         
-      end
-      begin
-        value = name_obj.RefersToRange.Value unless value
-      rescue WIN32OLERuntimeError
-        return opts[:default] if opts[:default]
-        raise SheetError, "cannot evaluate name #{name.inspect} in #{self.Name}"
+          raise SheetError, "cannot evaluate name #{name.inspect} in #{self.Name}"
+        end
       end
       if value == -2146826259
         return opts[:default] if opts[:default]
-        raise SheetError, "cannot find or evaluate name #{name.inspect} in #{self.name}"
-      end
+        raise SheetError, "cannot evaluate name #{name.inspect} in #{self.Name}"
+      end 
       return opts[:default] if (value.nil? && opts[:default])
-      value
+      value      
     end
     
     # assigns a value to a range
@@ -192,7 +203,7 @@ module RobustExcelOle
       begin
         range = self.Range(name)
       rescue WIN32OLERuntimeError
-        raise SheetError, "range named #{name.inspect} not in #{self.name}"
+        raise SheetError, "name #{name.inspect} not in #{self.name}"
       end
       begin
         range.Value = value
@@ -228,6 +239,19 @@ module RobustExcelOle
       super
     end
 
+    def self.book_class   # :nodoc: #
+      @book_class ||= begin
+        module_name = self.parent_name
+        "#{module_name}::Book".constantize
+      rescue NameError => e
+        book
+      end
+    end
+
+    def book_class        # :nodoc: #
+      self.class.book_class
+    end
+
     private
 
     def method_missing(name, *args)    # :nodoc: #

data/lib/robust_excel_ole/version.rb

@@ -1,3 +1,3 @@
 module RobustExcelOle
-  VERSION = "0.5"
+  VERSION = "0.5.1"
 end

data/spec/book_spec.rb

@@ -1124,7 +1124,7 @@ describe Book do
         sheet = @book.sheet(2)
         sheet.Activate
         sheet[2,3].Activate
-        sheet2 = @book2[2]
+        sheet2 = @book2.sheet(2)
         sheet2.Activate
         sheet2[3,2].Activate
         Excel.current.should == @book.excel

data/spec/book_specs/book_open_spec.rb

@@ -319,7 +319,7 @@ describe Book do
       it "should raise an error if no Excel or Book is given" do
         expect{
           Book.open(@simple_file, :force_excel => :b)
-          }.to raise_error(ExcelError, "receiver instance is neither an Excel nor a Book")
+          }.to raise_error(ExcelErrorOpen, "given object is neither an Excel, a Workbook, nor a Win32ole")
       end
 
       it "should do force_excel even if both force_ and default_excel is given" do
@@ -329,21 +329,54 @@ describe Book do
         book2.excel.should_not == @book.excel 
         book2.should_not == @book
       end
-    end
 
-    context "with another :force_excel" do
-      it "should do force_excel even if both force_ and default_excel is given" do
-        book2 = Book.open(@simple_file, :force_excel => nil)
+      it "should do default_excel if force_excel is nil" do
+        book2 = Book.open(@another_simple_file, :force_excel => nil)
+        book2.should be_alive
+        book2.should be_a Book
+        book2.excel.should == @book.excel
+      end
+
+      it "should force_excel with :reuse" do
+        book2 = Book.open(@different_file, :force_excel => :reuse)
         book2.should be_alive
         book2.should be_a Book
+        book2.excel.should == @book.excel
+      end
+
+      it "should force_excel with :reuse even if :default_excel says sth. else" do
+        book2 = Book.open(@different_file, :force_excel => :reuse, :default_excel => :new)
+        book2.should be_alive
+        book2.should be_a Book
+        book2.excel.should == @book.excel
       end
+
+      it "should open force_excel with :reuse when reopening and the Excel is not alive even if :default_excel says sth. else" do
+        excel2 = Excel.new(:reuse => false)
+        excel1_hwnd = @book.excel.hwnd
+        @book.excel.close
+        book2 = Book.open(@simple_file, :force_excel => :reuse, :default_excel => :new)
+        book2.should be_alive
+        book2.should be_a Book
+        book2.excel.should_not == excel2
+        book2.excel.hwnd.should == excel1_hwnd
+      end
+
+      it "should force_excel with :reuse when reopening and the Excel is not alive even if :default_excel says sth. else" do
+        book2 = Book.open(@different_file, :force_excel => :new)
+        book2.excel.close
+        book3 = Book.open(@different_file, :force_excel => :reuse, :default_excel => :new)
+        book3.should be_alive
+        book3.should be_a Book
+        book3.excel.should == @book.excel
+      end
+   
     end
 
     context "with :default_excel" do
 
       before do
-        excel = Excel.new(:reuse => false)
-        @book = Book.open(@simple_file)
+        @book = Book.open(@simple_file, :visible => true)
       end
 
       after do
@@ -417,6 +450,20 @@ describe Book do
         book2.close
       end
 
+      it "should reopen the book in the Excel where it was opened most recently" do
+        excel1 = @book.excel
+        excel2 = Excel.new(:reuse => false)
+        @book.close
+        book2 = Book.open(@simple_file, :default_excel => :reuse)
+        book2.excel.should == excel1
+        book2.close
+        book3 = Book.open(@simple_file, :force_excel => excel2)
+        book3.close
+        book3 = Book.open(@simple_file, :default_excel => :reuse)
+        book3.excel.should == excel2
+        book3.close
+      end
+
       it "should reopen a book in the excel instance where it was opened most recently" do
         book2 = Book.open(@simple_file, :force_excel => :new)
         @book.close
@@ -430,6 +477,37 @@ describe Book do
         book3.should_not == @book
       end
 
+      it "should open the book in a new excel if the book was not opened before" do
+        book2 = Book.open(@different_file, :default_excel => :reuse)
+        book2.excel.should == @book.excel
+        book3 = Book.open(@another_simple_file, :default_excel => :new)
+        book3.excel.should_not == @book.excel
+      end
+
+      it "should open the book in a new excel if the book was opened before but the excel has been closed" do
+        excel = @book.excel
+        excel2 = Excel.new(:reuse => false)
+        excel.close
+        book2 = Book.open(@simple_file, :default_excel => :new)
+        book2.excel.should_not == excel2
+        book2.close
+      end
+
+      it "should open the book in a given excel if the book was not opened before" do
+        book2 = Book.open(@different_file, :default_excel => :reuse)
+        book2.excel.should == @book.excel
+        excel = Excel.new(:reuse => false)
+        book3 = Book.open(@another_simple_file, :default_excel => excel)
+        book3.excel.should == excel
+      end
+
+      it "should open the book in a given excel if the book was opened before but the excel has been closed" do
+        excel2 = Excel.new(:reuse => false, :visible => true)
+        @book.excel.close        
+        book2 = Book.open(@simple_file, :visible => true, :default_excel => excel2)
+        book2.excel.should == excel2
+      end
+
       it "should open a new excel, if the book cannot be reopened" do
         @book.close
         new_excel = Excel.new(:reuse => false)
@@ -616,7 +694,7 @@ describe Book do
           it "should raise an error, if :if_obstructed is :raise" do
             expect {
               @new_book = Book.open(@simple_file, :if_obstructed => :raise)
-            }.to raise_error(ExcelErrorOpen, /blocked by a book with the same name in a different path: "workbook.xls"/)
+            }.to raise_error(ExcelErrorOpen, /blocked by a book with the same name in a different path/)
           end
 
           it "should close the other book and open the new book, if :if_obstructed is :forget" do
@@ -640,7 +718,7 @@ describe Book do
               if :if_obstructed is :close_if_saved" do
             expect{
               @new_book = Book.open(@simple_file, :if_obstructed => :close_if_saved)
-            }.to raise_error(ExcelErrorOpen, /workbook with the same name in a different path is unsaved: "workbook.xls"/)
+            }.to raise_error(ExcelErrorOpen, /workbook with the same name in a different path is unsaved/)
             @book.save
             @new_book = Book.open(@simple_file, :if_obstructed => :close_if_saved)
             @book.should_not be_alive
@@ -662,7 +740,7 @@ describe Book do
           it "should raise an error, if :if_obstructed is default" do
             expect {
               @new_book = Book.open(@simple_file)              
-            }.to raise_error(ExcelErrorOpen, /blocked by a book with the same name in a different path: "workbook.xls"/)
+            }.to raise_error(ExcelErrorOpen, /blocked by a book with the same name in a different path/)
           end         
 
           it "should raise an error, if :if_obstructed is invalid option" do

data/spec/book_specs/book_save_spec.rb

@@ -131,7 +131,7 @@ describe Book do
         File.exist?(@simple_file_other_path).should be_true
         expect{
           @book2.save_as(@simple_file_other_path, :if_exists => :overwrite, :if_obstructed => :raise)
-        }.to raise_error(ExcelErrorSave, /blocked by another workbook: "workbook.xls"/)
+        }.to raise_error(ExcelErrorSave, /blocked by another workbook/)
       end
 
       it "should close the blocking workbook without saving, and save the current workbook with :if_obstructed => :forget" do
@@ -235,7 +235,7 @@ describe Book do
         File.exist?(@simple_file_other_path).should be_true
         expect{
           @book2.save_as(@simple_file_other_path, :if_exists => :overwrite)
-        }.to raise_error(ExcelErrorSave, /blocked by another workbook: "workbook.xls"/)
+        }.to raise_error(ExcelErrorSave, /blocked by another workbook/)
       end
 
       it "should raise an error if the file does not exist and an workbook with the same name and other path exists" do
@@ -243,7 +243,7 @@ describe Book do
         File.exist?(@simple_file_other_path).should be_false
         expect{
           @book2.save_as(@simple_file_other_path, :if_exists => :overwrite, :if_obstructed => :raise)
-          }.to raise_error(ExcelErrorSave, /blocked by another workbook: "workbook.xls"/)
+          }.to raise_error(ExcelErrorSave, /blocked by another workbook/)
       end
 
       it "should raise an error if the file exists and an workbook with the same name and other path exists" do

data/spec/book_specs/book_unobtr_spec.rb

@@ -121,7 +121,7 @@ describe Book do
         expect{
           Book.unobtrusively(@simple_file, :invalid_option) do |book|
           end
-        }.to raise_error(ExcelErrorOpen, "given object is neither an Excel, a Book, nor a Win32ole")
+        }.to raise_error(ExcelErrorOpen, "given object is neither an Excel, a Workbook, nor a Win32ole")
       end
 
       it "should be visible and displayalerts" do
@@ -383,7 +383,7 @@ describe Book do
         old_cell_value = sheet[1,1].value
         @book.close
         @book.should_not be_alive
-        Excel.close_all
+        Excel.kill_all
         Book.unobtrusively(@simple_file, :hidden, :keep_open => true) do |book|
           book.should be_a Book
           book.excel.should_not == @book.excel

data/spec/excel_spec.rb

@@ -133,6 +133,27 @@ module RobustExcelOle
       end
     end
 
+    context "current" do
+      
+      it "should reuse the first opened Excel instance if not the first opened Excel instance was closed" do
+        excel1 = Excel.create
+        excel2 = Excel.create
+        excel2.close
+        excel3 = Excel.current
+        excel3.should === excel1
+      end
+
+      it "should create a new Excel with the same hwnd as the first opened Excel if the first opened Excel was closed" do
+        excel1 = Excel.create
+        excel1_hwnd = excel1.hwnd
+        excel2 = Excel.create
+        excel1.close
+        excel3 = Excel.current
+        excel3.should_not === excel2
+        excel3.hwnd.should == excel1_hwnd
+      end
+    end
+
     context "excel_processes" do
         
       before do
@@ -383,19 +404,12 @@ module RobustExcelOle
       context "with :if_unsaved => :alert" do
         before do
           @key_sender = IO.popen  'ruby "' + File.join(File.dirname(__FILE__), '/helpers/key_sender.rb') + '" "Microsoft Excel" '  , "w"
-          #book1 = Book.open(@simple_file, :read_only => true)
           book2 = Book.open(@simple_file, :force_excel => :new)
-          #book3 = Book.open(@another_simple_file, :force_excel => book2.excel)
-          #book4 = Book.open(@different_file, :force_excel => :new)
           #@excel1 = book1.excel
           @excel2 = book2.excel
-          #@excel4 = book4.excel
           sheet2 = book2.sheet(1)
           @old_cell_value2 = sheet2[1,1].value
           sheet2[1,1] = sheet2[1,1].value == "foo" ? "bar" : "foo"
-          #sheet3 = book3[0]
-          #@old_cell_value3 = sheet3[1,1].value
-          #sheet3[1,1] = sheet3[1,1].value == "foo" ? "bar" : "foo"          
         end
 
         after do
@@ -405,47 +419,31 @@ module RobustExcelOle
         it "should save if user answers 'yes'" do
           @key_sender.puts "{enter}"
           Excel.close_all(:if_unsaved => :alert)
-          #@excel1.should_not be_alive
-          @excel2.should_not be_alive
-          #@excel4.should_not be_alive
-          #@excel5.should_not be_alive
           new_book2 = Book.open(@simple_file)
           new_sheet2 = new_book2.sheet(1)
           new_sheet2[1,1].value.should_not == @old_cell_value2
           new_book2.close   
-          #new_book3 = Book.open(@another_simple_file)
-          #new_sheet3 = new_book3[0]
-          #new_sheet3[1,1].value.should == @old_cell_value3
-          #new_book3.close       
         end
 
         it "should not save if user answers 'no'" do            
           @key_sender.puts "{right}{enter}"
           @key_sender.puts "{right}{enter}"
           Excel.close_all(:if_unsaved => :alert)
-          #@excel1.should_not be_alive
           @excel2.should_not be_alive
-          #@excel4.should_not be_alive
-          #@excel5.should_not be_alive
           new_book2 = Book.open(@simple_file)
           new_sheet2 = new_book2.sheet(1)
           new_sheet2[1,1].value.should == @old_cell_value2
           new_book2.close   
-          #new_book4 = Book.open(@different_file)
-          #new_sheet4 = new_book4[0]
-          #new_sheet4[1,1].value.should_not == @old_cell_value4
-          #new_book4.close   
         end
 
-      #  it "should not save if user answers 'cancel'" do
-      #    @key_sender.puts "{left}{enter}"
-      #    @key_sender.puts "{left}{enter}"
-      #    @key_sender.puts "{left}{enter}"
-      #    @key_sender.puts "{left}{enter}"
-      #    expect{
-      #      Excel.close_all(:if_unsaved => :alert)
-      #      }.to raise_error(ExcelUserCanceled, "close: canceled by user")
-      #  end
+        #it "should not save if user answers 'cancel'" do
+        #  @key_sender.puts "{left}{enter}"
+        #  @key_sender.puts "{left}{enter}"
+        #  @key_sender.puts "{left}{enter}"
+        #  expect{
+        #    Excel.close_all(:if_unsaved => :alert)
+        #  }.to raise_error(ExcelUserCanceled, "close: canceled by user")
+        # end
       end
     end
 
@@ -465,6 +463,30 @@ module RobustExcelOle
           @excel.should_not be_alive
           @book.should_not be_alive
         end
+
+        it "should close the Excel hard" do
+          @excel.should be_alive
+          @book.should be_alive
+          @excel.close(:hard => true)
+          @excel.should_not be_alive
+          @book.should_not be_alive
+        end
+
+        it "should close the Excel without destroying the others" do
+          @excel.should be_alive
+          excel2 = Excel.create
+          @excel.close
+          @excel.should_not be_alive
+          excel2.should be_alive
+        end
+
+        it "should close the Excel hard without destroying the others" do
+          @excel.should be_alive
+          excel2 = Excel.create
+          @excel.close(:hard => true)
+          @excel.should_not be_alive
+          excel2.should be_alive
+        end
       end
 
       context "with unsaved workbooks" do
@@ -490,7 +512,7 @@ module RobustExcelOle
           expect{
             @excel.close(:if_unsaved => :raise)
           }.to raise_error(ExcelErrorClose, "Excel contains unsaved workbooks")
-        end
+        end        
 
         it "should close the Excel without saving the workbook" do
           @excel.should be_alive
@@ -560,6 +582,7 @@ module RobustExcelOle
           end
           result.should be_empty
         end
+
       end
 
       context "with :if_unsaved => :alert" do
@@ -741,21 +764,42 @@ module RobustExcelOle
     context "with calculation" do
 
       before do
-        @excel1 = Excel.new(:visible => true)
+        @excel1 = Excel.new
       end
 
       it "should not set calculation mode when no workbook is opened" do
+        old_calculation_mode = @excel1.Calculation
         @excel1.with_calculation(:automatic) do
-          @excel1.Calculation.should_not == -4105
+          @excel1.Calculation.should == old_calculation_mode
         end
+        @excel1.with_calculation(:manual) do
+          @excel1.Calculation.should == old_calculation_mode
+        end
+        @excel1.set_calculation(:automatic)
+        @excel1.Calculation.should == old_calculation_mode
+        @excel1.set_calculation(:manual)
+        @excel1.Calculation.should == old_calculation_mode
       end
 
-      it "should set calculation mode to manual" do
+      it "should set calculation mode to manual and reset to the previous value" do
         b = Book.open(@simple_file)
+        calculation_mode_old = @excel1.Calculation
+        calculation_before_save_old = @excel1.CalculateBeforeSave
         @excel1.with_calculation(:manual) do
           @excel1.Calculation.should == -4135
           @excel1.CalculateBeforeSave.should be_false
         end
+        @excel1.Calculation.should == calculation_mode_old
+        @excel1.CalculateBeforeSave.should == calculation_before_save_old
+      end
+
+      it "should set calculation mode to manual" do
+        b = Book.open(@simple_file)
+        calculation_mode_old = @excel1.Calculation
+        calculation_before_save_old = @excel1.CalculateBeforeSave
+        @excel1.set_calculation(:manual)
+        @excel1.Calculation.should == -4135
+        @excel1.CalculateBeforeSave.should be_false
       end
 
       it "should set calculation mode automatic" do

data/spec/sheet_spec.rb

@@ -95,7 +95,7 @@ describe Sheet do
 
   describe 'access cell' do
 
-    describe "#[]" do      
+    describe "#[,]" do      
 
       context "access [1,1]" do
 
@@ -388,7 +388,57 @@ describe Sheet do
       end
     end
 
-    describe "nameval, set_nameval, [], []=" do
+    describe "[], []=" do
+      before do
+        @book1 = Book.open(@dir + '/another_workbook.xls')
+        @sheet1 = @book1.sheet(1)
+      end
+
+      after do
+        @book1.close(:if_unsaved => :forget)
+      end   
+
+      it "should return value of a defined name" do
+        @sheet1["firstcell"].should == "foo"
+      end
+
+      it "should return value of a defined name" do
+        @sheet1["new"].should == "foo"         
+        @sheet1["one"].should == 1.0    
+        @sheet1["four"].should == [[1,2],[3,4]]
+        @sheet1["firstrow"].should == [[1,2]]
+      end  
+
+      it "should evaluate named formula" do
+        @sheet1["named_formula"].should == 4
+      end                
+
+      it "should evaluate a formula" do
+        @sheet1["another_formula"].should == 5
+      end      
+
+      it "should raise an error if name not defined" do
+        expect {
+          @sheet1["foo"]
+        }.to raise_error(SheetError, /name "foo" not in Sheet1/)        
+      end
+
+      it "should set a range to a value" do
+        @sheet1[1,1].Value.should == "foo"
+        @sheet1["firstcell"] = "bar"
+        @sheet1[1,1].Value.should == "bar"
+        @sheet1["new"] = "bar"
+        @sheet1["new"].should == "bar"
+      end
+
+      it "should raise an error if name cannot be evaluated" do
+        expect{
+          @sheet1["foo"] = 1
+          }.to raise_error(SheetError, /name "foo" not in Sheet1/)
+      end
+    end
+
+    describe "nameval, set_nameval" do
 
       before do
         @book1 = Book.open(@dir + '/another_workbook.xls')
@@ -401,25 +451,23 @@ describe Sheet do
 
       it "should return value of a defined name" do
         @sheet1.nameval("firstcell").should == "foo"
-        @sheet1["firstcell"].should == "foo"
-      end        
+      end
 
       it "should return default value if name not defined and default value is given" do
         @sheet1.nameval("foo", :default => 2).should == 2
       end
 
       it "should evaluate a formula" do
-        @sheet1.nameval("named_formula").should == 4
-        @sheet1["named_formula"].should == 4
-      end
+        @sheet1.nameval("another_formula").should == 5
+      end      
 
       it "should raise an error if name not defined" do
         expect {
           @sheet1.nameval("foo")
-        }.to raise_error(SheetError, /cannot find or evaluate name "foo" in Sheet1/)
+        }.to raise_error(SheetError, /name "foo" not in Sheet1/)
         expect {
-          @sheet1["foo"]
-        }.to raise_error(SheetError, /cannot find or evaluate name "foo" in Sheet1/)
+          @sheet1.nameval("named_formula")
+        }.to raise_error(SheetError, /name "named_formula" not in Sheet1/)
       end
 
       it "should set a range to a value" do
@@ -428,18 +476,12 @@ describe Sheet do
         @sheet1.set_nameval("firstcell","bar")
         @sheet1.nameval("firstcell").should == "bar"
         @sheet1[1,1].Value.should == "bar"
-        @sheet1["firstcell"] = "foo"
-        @sheet1.nameval("firstcell").should == "foo"
-        @sheet1[1,1].Value.should == "foo"
       end
 
       it "should raise an error if name cannot be evaluated" do
         expect{
           @sheet1.set_nameval("foo", 1)
-          }.to raise_error(SheetError, /name "foo" not in Sheet1/)
-        expect{
-          @sheet1["foo"] = 1
-          }.to raise_error(SheetError, /name "foo" not in Sheet1/)
+        }.to raise_error(SheetError, /name "foo" not in Sheet1/)
       end
     end
 

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: robust_excel_ole
 version: !ruby/object:Gem::Version 
-  hash: 1
+  hash: 9
   prerelease: false
   segments: 
   - 0
   - 5
-  version: "0.5"
+  - 1
+  version: 0.5.1
 platform: ruby
 authors: 
 - traths
@@ -14,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2016-06-07 00:00:00 +02:00
+date: 2016-06-17 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency