robust_excel_ole 1.1 → 1.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e288f5c2c1de7a23b3f3d38bcefa7dc9fb78661b
+  data.tar.gz: 8c396bc079707bf0602ed3b6e6083d4f04569a0a
+SHA512:
+  metadata.gz: 195f2c061fdffdb4ae22bb19f245b059a5620f894998cb754a14685a25d31f1f8b227dac7c3c8f9e34d9598d3b9a9ead74a333795fe3c7ea49be609aef6111ae
+  data.tar.gz: e77b113d6b9791e4a3304bbc629f3ba067594c49f20a61d54e5f1d1b6cba12bcfd9322b2ed541ccfddca6914865fd6efb47ce7170db12f388bf9ae4e9a4db5e7

data/Changelog

@@ -1,8 +1,22 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
+## [1.1.1] - 2018-20-4
+
+### Added
+  - Book#save, save_as: options: discoloring
+  - Book#set_nameval, Sheet, Excel#set_nameval, set_rangeval: option :color
+
+### Changed
+
+  - renamed: Excel.known_excel_instances instead of excel_processes
+
 ## [1.1] - 2017-09-29
 
+### Added
+
+  - Book.save, save_as, close
+
 ## [1.0.4] - 2017-08-30
 
 ## [1.0.3] - 2017-08-27
@@ -23,8 +37,8 @@ All notable changes to this project will be documented in this file.
 
 ### Added
  
- - Book#open : options :calculation
- - Excel#new : options :calculation, :screen_updating
+ - Book.open : options :calculation
+ - Excel.new : options :calculation, :screen_updating
  - Excel#calculation, calculation=, screen_updating, screenupdating=
 
 ### Changed
@@ -123,18 +137,18 @@ All notable changes to this project will be documented in this file.
 ## [0.3.7] - 2015-12-04
 
 ### Added
- - Book::new: includes lifting Win32Ole objects
+ - Book.new: includes lifting Win32Ole objects
  - Book: class synonym: Workbook
- - Book::open: can force_excel can contain an win32ole object
+ - Book.open: can force_excel can contain an win32ole object
  - Book#excel_of
  - Book: consider Excel version for opening linked workbooks
  - Book#close: with keep_open
- - Excel::new: includes lifting Win32ole objects
- - Excel::close_all: with a little time out
+ - Excel.new: includes lifting Win32ole objects
+ - Excel.close_all: with a little time out
  - Excel: sublassing for Books
  
 ### Changed
- - Excel::close_all: bug fix
+ - Excel.close_all: bug fix
  - Excel#recreate: reopening closed workbooks, restrict reopening, visible, displayalerts
 
  
@@ -143,12 +157,12 @@ All notable changes to this project will be documented in this file.
 
 ### Added
 - Excel#recreate: reopening a closed Excel
-- Excel::new(:reuse => <WIN32OLE_excel>): 
+- Excel.new(:reuse => <WIN32OLE_excel>): 
   uplifting an Excel represented as object of the class WIN32OLE to an object of the class Excel
-- Excel#close, Excel::close_all: with managing unsaved workbooks
-- Excel::kill_all
-- Excel::excel_processes: yield Excel objects opened with RobustExcelOle
-- Book::new: uplifting a WIN32OLE object to a Book object
+- Excel#close, Excel.close_all: with managing unsaved workbooks
+- Excel.kill_all
+- Excel.excel_processes: yield Excel objects opened with RobustExcelOle
+- Book.new: uplifting a WIN32OLE object to a Book object
 - Subclassing for Sheet
 - Method missing: error messages for dead objects
 - trace to stdout or file

data/README.rdoc

@@ -32,16 +32,16 @@ RobustExcelOle enables opening and processing Excel files (or workbooks) in seve
 
 For example, suppose you want to open a workbook and make it visible.
 
-  book1 = Book.open('workbook.xls', :visible => true)
+  book1 = Workbook.open('workbook.xls', :visible => true)
 
 Now we want to open another workbook in a different Excel instance.
 
-  book2 = Book.open('workbook2.xls', :force => {:excel => :new}, :visible => true)
+  book2 = Workbook.open('workbook2.xls', :force => {:excel => :new}, :visible => true)
 
 We can also create a third Excel instance and open another workbook in this instance.
 
   excel1 = Excel.create
-  book3 = Book.open('workbook3.xls', :force => {:excel => excel1}, :visible => true)
+  book3 = Workbook.open('workbook3.xls', :force => {:excel => excel1}, :visible => true)
 
 Another feature that RobustExcelOle povides is reopening workbooks after closing them.
 
@@ -51,45 +51,45 @@ Another feature that RobustExcelOle povides is reopening workbooks after closing
 A workbook is opened by default in the Excel instance where it was open before most recently.
 
    book1.close
-   book1 = Book.open('workbook.xls') 
+   book1 = Workbook.open('workbook.xls') 
 
 If this Excel instance is damaged or closed, then options control whether the workbook shall be opened in the current (active), a new or a given Excel instance.
 
-  book1 = Book.open('workbook.xls', :default => {:excel => :new})
+  book1 = Workbook.open('workbook.xls', :default => {:excel => :new})
 
 The workbook can also be forced to be opened in the current, new or given Excel instance, no matter if and where it was opened before, e.g.
 
-  book2 = Book.open('workbook.xls', :force => {:excel => excel1})
+  book2 = Workbook.open('workbook.xls', :force => {:excel => excel1})
 
 As a further feature, RobustExcelOle allows processing workbooks, while still supporting user's interactions: The commands enable to open, close, reopen, read, modify, write and save Excel files, without the need of the user's interaction, and even without the user noticing. Thus, while running a script containing RobustExcelOle commands, the user can open and process Excel files in any Excel instances at any time. RobustExcelOle manages the complex cases of conflicts that might occur such that the user does not need to interfere and the script can continue.
 
 For example, suppose you want to process a list of workbooks. RobustExcelOle allows to rapidly open, manipulate, close and save these workbooks. Now assume, the workbook "workbook.xls" is being processed, while the user has opened this workbook, has modified but not saved it yet. Excel would prompt a message and ask the user what to do. RobustExcelOle solves this conflict by using an option that states whether the changes of the user should be saved (accepted) or discarded before opening the workbook:
 
-  book = Book.open('workbook.xls', :if_unsaved => :accept)
+  book = Workbook.open('workbook.xls', :if_unsaved => :accept)
 
 Similarly, if the user has opened a workbook that has the same name but a different path, the conflict is solved via an option.
 
-  book1 = Book.open('path1/workbook.xls')
+  book1 = Workbook.open('path1/workbook.xls')
     ...
-  book2 = Book.open('workbook.xls', :if_obstructed => :forget)
+  book2 = Workbook.open('workbook.xls', :if_obstructed => :forget)
 
 There are twelve options that control opening workbooks. 
 
 Finally, RobustExcelOle allows unobtrusively reading and modifying workbooks, i.e. accessing workbooks without changing their "status". The status comprises whether the workbook is open or closed, saved or unsaved, read-only or writable, visible or invisible, whether the calculation mode is manual or automatic, and checking compatibility is done or not done. 
 
-  Book.for_modifying('workbook.xls') do |book|
+  Workbook.for_modifying('workbook.xls') do |book|
     # do something
   end
 
-  Book.for_reading('workbook.xls') do |book|
+  Workbook.for_reading('workbook.xls') do |book|
     # do something
   end
 
-=== The Book objects and identity transparency
+=== The Workbook objects and identity transparency
 
-An Excel file (or workbook) is represented by a Book object. A Book object is defined by the full name of the workbook and the Excel instance in which it is opened. RobustExcelOle aims to ensure identity transparency.
-Identity transparency means that the same Book objects refer to the same Excel files, and vice versa.
-In other words, a Book objects is a proxy of an Excel file.
+An Excel file (or workbook) is represented by a Workbook object. A Workbook object is defined by the full name of the workbook and the Excel instance in which it is opened. RobustExcelOle aims to ensure identity transparency.
+Identity transparency means that the same Workbook objects refer to the same Excel files, and vice versa.
+In other words, a Workbook objects is a proxy of an Excel file.
 
 Here are some more details about opening, closing, reading, writing and modifying Excel files.
 
@@ -97,11 +97,11 @@ Here are some more details about opening, closing, reading, writing and modifyin
 
 Let's have a look at an example. Suppose, we want to open a workbook.
 
-  book = Book.open('workbook.xls')
+  book = Workbook.open('workbook.xls')
 
 We could do this in a block as well. The semantics is similar to, e.g.,  +File.open+.
 
-  Book.open('workbook.xls') do |book|
+  Workbook.open('workbook.xls') do |book|
     # do something with book
   end
 
@@ -111,15 +111,15 @@ Now let's make the workbook visible.
 
 We can do this in one step as well.
 
-  book = Book.open('workbook.xls', :visible => true)
+  book = Workbook.open('workbook.xls', :visible => true)
 
 Now we want to open another workbook in a new Excel instance.
 
-  book2 = Book.open('another_workbook.xls', :force => {:excel => :new}, :visible => true)
+  book2 = Workbook.open('another_workbook.xls', :force => {:excel => :new}, :visible => true)
 
 Then we open a third workbook in the second Excel instance. 
 
-  book3 = Book.open('different_workbook.xls', :force => {:excel => book2.excel})
+  book3 = Workbook.open('different_workbook.xls', :force => {:excel => book2.excel})
 
 We close the second workbook.
 
@@ -143,9 +143,9 @@ Now we assign a new value to this range.
 
   book2["new"] = "bar"
 
-or
+or, with coloring the cell,
 
-  book2.set_nameval("new", "bar")
+  book2.set_nameval("new", "bar", :color => 4)
 
 Then we access the first worksheet by
 
@@ -183,9 +183,9 @@ We get the value of a range
 
   sheet1.nameval("firstcell")    # => "hello"
 
-and set the value 
+and set the value, while coloring the cell
 
-  sheet1.set_nameval("firstcell", "foo")
+  sheet1.set_nameval("firstcell", "foo", :color => 4)
 
 We get the value of a range of a locally defined name.
 
@@ -221,6 +221,14 @@ Simple saving and closing can be also done in one step by
 
   book2.close(:if_unsaved => :save)
 
+When you want discolor all cells that have been colored when modifying them, then use
+  
+  book2.save(:discoloring => true)
+
+or
+
+  book2.save_as('example_workbook.xls', :if_exists => :overwrite, :discoloring => true)
+
 === Operating on Excel instances.
 
 Suppose we want to create an Excel object by connecting to the already running Excel instance.
@@ -241,7 +249,7 @@ or
 
 We open a workbook in this Excel instance.
 
-  book4 = Book.open('more_data/workbook', {:force => {:excel => excel2}})
+  book4 = Workbook.open('more_data/workbook', {:force => {:excel => excel2}})
 
 We close the Excel instance by
 
@@ -263,9 +271,9 @@ and set the value of this range by using
 
   excel2["firstcell"] = "bar"
 
-or
+or, with coloring the cell,
 
-  excel2.set_nameval("firstcell", "bar")
+  excel2.set_nameval("firstcell", "bar", :color => 4)
 
 We get and set the value of a range with a locally defined named by
 

data/README_detail.rdoc

@@ -27,12 +27,12 @@ The tool is optimised with help of rcov.
 
 Example:
   
-  book = Book.open('workbook.xls')
+  book = Workbook.open('workbook.xls')
 
 You can also open a workbook with a block. 
 The semantics is similar to, e.g.,  +File.open+.
 
-  Book.open('workbook.xls') do |book|
+  Workbook.open('workbook.xls') do |book|
     # do something
   end
 
@@ -92,49 +92,49 @@ Here are a few examples:
 
 If you want to open a workbook that was not opened before, or reopen a workbook that was open in an Excel instance that is now closed, in the current (active) Excel instance, then use
 
-  Book.open('workbook.xls', :default => {:excel => :current})
+  Workbook.open('workbook.xls', :default => {:excel => :current})
 
 or
   
-  Book.open('workbook.xls')
+  Workbook.open('workbook.xls')
 
 In case you want to open such a workbook in a new Excel instance, then use
 
-  Book.open('workbook.xls', :default => {:excel => :new})
+  Workbook.open('workbook.xls', :default => {:excel => :new})
 
 If you want to open a workbook in a new Excel instance, no matter if it was opened before, you can write
 
-  Book.open('workbook.xls', :force => {:excel => :new})
+  Workbook.open('workbook.xls', :force => {:excel => :new})
 
 You can also specify an Excel instance
 
   excel1 = Excel.create
   # something
-  Book.open('workbook.xls', :force => {:excel => excel1})
+  Workbook.open('workbook.xls', :force => {:excel => excel1})
 
 If you want to open the workbook and make its window visible, then use
 
-  book = Book.open('workbook.xls', :force => {:visible => true})
+  book = Workbook.open('workbook.xls', :force => {:visible => true})
 
 or
 
-  book = Book.open('workbook.xls', :visible => true)
+  book = Workbook.open('workbook.xls', :visible => true)
 
 You can combine options, e.g. 
 
-  Book.open('workbook.xls', :force => {:excel => :new, :visible => true})
+  Workbook.open('workbook.xls', :force => {:excel => :new, :visible => true})
 
 You can use some abbreviations, e.g. in this case
 
-  Book.open('workbook.xls', :f => {:e => :new, :v => true})  
+  Workbook.open('workbook.xls', :f => {:e => :new, :v => true})  
 
 If a workbook contains unsaved changes and a workbook with the same filename shall be opened, then the option +:if_unsaved+ manages this conflict. For example, if the workbook with the unsaved changes shall remain open, you can use
 
-  book = Book.open('workbook.xls', :if_unsaved => :accept)
+  book = Workbook.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, i.e. the first workbook blocks opening the other workbook, then the option +:if_obstructed+ handles this situation, e.g.
 
-  book = Book.open('path/workbook.xls', :if_obstructed => :forget)
+  book = Workbook.open('path/workbook.xls', :if_obstructed => :forget)
 
 Remarks:
 
@@ -163,7 +163,7 @@ The option specifies: If the workbook is unsaved, then
 
 A special feature of robust_excel_ole is that it allows to reopen workbooks after closing them.
 
-  book = Book.open('workbook.xls')
+  book = Workbook.open('workbook.xls')
   book.close
   book.reopen
 
@@ -171,17 +171,17 @@ The closed workbook is now alive again, i.e. is open and responds to Excel metho
 
 This feature is a result of providing identity transparence and storing the file name.
 
-=== The Book objects and transperence identity
+=== The Workbook objects and transperence identity
 
-An Excel file (or workbook) is represented by a Book object. A Book object is defined by the full name of the workbook and the Excel instance in which it is opened. RobustExcelOle aims to ensure identity transperency.
-Identity transparence means that the same Book objects refer to the same Excel files, and vice versa.
-In other words, a Book objects is a proxy of an Excel file.
+An Excel file (or workbook) is represented by a Workbook object. A Workbook object is defined by the full name of the workbook and the Excel instance in which it is opened. RobustExcelOle aims to ensure identity transperency.
+Identity transparence means that the same Workbook objects refer to the same Excel files, and vice versa.
+In other words, a Workbook objects is a proxy of an Excel file.
 
-=== Promoting a workbook to a Book object
+=== Promoting a workbook to a Workbook object
 
-A Book object can be created when giving an Excel workbook.
+A Workbook object can be created when giving an Excel workbook.
 
-   book = Book.new(win32ole_workbook)
+   book = Workbook.new(win32ole_workbook)
 
 
 === Saving a workbook.
@@ -215,27 +215,27 @@ If you want to save a workbook and overwrite the file if it exists before, then
 
 If a workbook blocks the workbook that should be saved, then the former one can be saved and closed before.
 
-  book = Book.open('workbook.xls')
-  book2 = Book.open('another_workbook.xls')
+  book = Workbook.open('workbook.xls')
+  book2 = Workbook.open('another_workbook.xls')
   book2.save_as('dir/workbook.xls', :if_exists => :overwrite, :if_obstructed => :save)  
 
 === Opening, closing and saving a workbook under a certain name
 
 You can open a workbook with given file name.
 
-  book = Book.open('workbook.xls')
+  book = Workbook.open('workbook.xls')
 
 You can save a workbook with given file name, if it is open.
 
-  Book.save('workbook.xls')
+  Workbook.save('workbook.xls')
 
 The workbook can be saved under a new file name, if it is open.
 
-  Book.save_as('workbook.xls', 'new_workbook.xls')
+  Workbook.save_as('workbook.xls', 'new_workbook.xls')
 
 Finally the workbook can be closed with a given filename.
 
-  Book.close('workbook.xls')
+  Workbook.close('workbook.xls')
 
 === Unobtrusively modifying a workbook
 
@@ -254,7 +254,7 @@ Options are the following:
                                      otherwise open in a new excel instance
 +:keep_open+::          let the workbook open after unobtrusively opening (default: false)
 
-  Book.unobtrusively('workbook.xls') do |book|
+  Workbook.unobtrusively('workbook.xls') do |book|
     # some modification
     sheet = book[0]
     sheet[1,1] = "c" 
@@ -262,7 +262,7 @@ Options are the following:
   
 The methods +for_reading+ and +for_modifying+ indicate unobtrusively reading or modifying.
 
-  Book.for_modifying('workbook.xls') do |book|
+  Workbook.for_modifying('workbook.xls') do |book|
     # some modification
     sheet = book[0]
     sheet[1,1] = "c" 
@@ -272,14 +272,14 @@ The methods +for_reading+ and +for_modifying+ indicate unobtrusively reading or
 
 This method ensures keeping the save status of the workbook
 
-  book = Book.open('workbook.xls')
+  book = Workbook.open('workbook.xls')
   book.retain_saved do
     # some reading or modifying
   end
 
 === Checking whether the workbook is alive.
 
-This method finds out whether the Excel workbook that is referenced by the Book object responds to methods.
+This method finds out whether the Excel workbook that is referenced by the Workbook object responds to methods.
 
   if book.alive? then sheet = book[0] end
 
@@ -301,7 +301,11 @@ You can set the contents of a range with
 
 or
 
-  book.set_nameval("name") = "value"
+  book.set_nameval("name", value)
+
+You can also specify the color of a changed range: 
+  
+  book.set_nameval("name", value, :color => 4)
 
 === Bringing a workbook to the focus.
 
@@ -345,7 +349,7 @@ and
 
   sheet = book.last_sheet  
 
-You can access all sheet objects by using the methods Book#each.
+You can access all sheet objects by using the methods Workbook#each.
 
   book.each do |sheet|               
     # do something with sheet
@@ -431,6 +435,10 @@ and set the value of this range by
 
   sheet.set_rangeval(name,value)
 
+You can also specify the color of a modified range:
+ 
+  sheet.set_rangeval(name, value, :color => 4)
+
 === Adding and copying a worksheet.
 
 You can add (append) an empty worksheet using
@@ -592,7 +600,7 @@ You can set the calculation mode of an Excel instance to manual or automatic.
 You can do it in a block:
 
   excel = Excel.create
-  book = Book.open('workbook.xls')
+  book = Workbook.open('workbook.xls')
   excel.with_calculation(:manual) do 
     # do something
   end
@@ -600,7 +608,7 @@ You can do it in a block:
 === Getting and setting the contents of a named range in an Excel application
 
   excel = Excel.create
-  book = Book.open('another_workbook.xls')
+  book = Workbook.open('another_workbook.xls')
 
 You can get the value of a range by using
 
@@ -618,6 +626,10 @@ or
 
   excel.set_nameval(name,value)
 
+You can also specify the color of a changed range: 
+  
+  excel.set_nameval(name, value, :color => 4)
+
 === Retaining the saved-status of all workbooks
 
 You can operate in some Excel instance and retain the saved-status of all workbooks.
@@ -635,6 +647,10 @@ You can get the value of a range of a locally defined name by
 and set the value of this range with
 
   excel.set_rangeval(name,value)
+
+You can also specify the color of a changed range: 
+  
+  excel.set_rangeval(name, value, :color => 4)  
   
 
 === Examples
@@ -643,7 +659,7 @@ and set the value of this range with
 
 We open a workbook.
 
-  book = Book.open('workbook.xls')
+  book = Workbook.open('workbook.xls')
 
 Then we access a sheet via its name.
 
@@ -669,15 +685,15 @@ Finally we close the workbook.
 
 We open a workbook.
 
-  book = Book.open('workbook.xls')
+  book = Workbook.open('workbook.xls')
 
 open it also in a new Excel instance and make it visible.
 
-  new_book = Book.open('workbook.xls', :force => {:excel => :new}, :visible => true)
+  new_book = Workbook.open('workbook.xls', :force => {:excel => :new}, :visible => true)
 
 and open another workbook in a the first Excel instance.
 
-  another_book = Book.open('another_workbook.xls', :force => {:excel => book.excel})
+  another_book = Workbook.open('another_workbook.xls', :force => {:excel => book.excel})
 
 Then we close the workbooks.
 
@@ -696,14 +712,14 @@ The writable workbook is being prefered.
 
 We want to open yet another workbook. Since the workbook was not open before, reopening the workbook fails and the :default-excel option applies. According to :default => {:excel => :new} a new Excel is created, and the workbook is opened there.
 
-  different_book = Book.open('different.xls', :default => {:excel => :new})
+  different_book = Workbook.open('different.xls', :default => {:excel => :new})
   
 
 === Example 3
 
 We open a workbook.
 
-  book = Book.open('workbook.xls')
+  book = Workbook.open('workbook.xls')
 
 We want to add a copy of the first sheet and insert it after the second sheet.
 
@@ -711,7 +727,7 @@ We want to add a copy of the first sheet and insert it after the second sheet.
 
 Then we open a new workbook with the same name in a new Excel, and leave the workbook that contains unsaved changes in the old Excel.
 
-  new_book = Book.open('workbook.xls', :if_unsaved => :new_excel)
+  new_book = Workbook.open('workbook.xls', :if_unsaved => :new_excel)
 
 We acccess the first sheet and change the first cell.
 
@@ -720,7 +736,7 @@ We acccess the first sheet and change the first cell.
 
 Then we open a workbook with the same name in the running Excel while discarding the workbook that contained unsaved changes.
 
-  third_book = Book.open('workbook.xls', :if_unsaved => :forget)
+  third_book = Workbook.open('workbook.xls', :if_unsaved => :forget)
 
 Now we add a sheet.
 
@@ -738,11 +754,11 @@ We close the first workbook and save it before.
 
 We open a workbook.
 
-  book1 = Book.open('workbook.xls')
+  book1 = Workbook.open('workbook.xls')
 
 Then we open a workbook with the same name in a different path, while closing the workbook opened before.
 
-  book2 = Book.open('more/workbook.xls', :if_obstructed => :forget)
+  book2 = Workbook.open('more/workbook.xls', :if_obstructed => :forget)
 
 We change its first cell.
 
@@ -751,12 +767,12 @@ We change its first cell.
 
 Now we open a workbook with the same name again in a different path. while saving and closing the other workbook.
 
-  book3 = Book.open('workbook.xls', :if_obstructed => :save)
+  book3 = Workbook.open('workbook.xls', :if_obstructed => :save)
 
 Then we open a workbook with the same name in a different path. 
 The other workbook will be closed, because it does not contain unsaved changes.
 
-  book4 = Book.open('more/workbook.xls', :if_obstructed => :close_if_unsaved)
+  book4 = Workbook.open('more/workbook.xls', :if_obstructed => :close_if_unsaved)
 
 
 Finally we close this workbook.
@@ -768,7 +784,7 @@ Finally we close this workbook.
 
 We open a workbook
 
-  book = Book.open('workbook.xls')
+  book = Workbook.open('workbook.xls')
 
 and print its first cell.
 
@@ -777,7 +793,7 @@ and print its first cell.
 
 Then we unobtrusively modify the workbook.
 
-  Book.unobtrusively('workbook.xls') do |book|
+  Workbook.unobtrusively('workbook.xls') do |book|
     sheet = book.sheet(1)
     sheet[1,1] = 'simple'
   end
@@ -794,7 +810,7 @@ RobustExcelOle started as a simple fork from tomiacannondale's wrap_excel adapte
 The functionality of wrap_excel is optimised and extended by a lot of new features.
 Most notable extensions include:
 * workbooks can be opened in already running Excel instances (instead of opening a new Excel whenever a book is opened)
-* a workbook management system stores all workbooks that have been open. This workbook store is being used, e.g., for reopening a workbook that has been closed before. It provides transparency identity, i.e., equal Excel workbooks correspond to equal Book objects of RobustExcelOle.
+* a workbook management system stores all workbooks that have been open. This workbook store is being used, e.g., for reopening a workbook that has been closed before. It provides transparency identity, i.e., equal Excel workbooks correspond to equal Workbook objects of RobustExcelOle.
 
 Some features in RobustExcelOle that are not compatible with wrap_excel:
 * +open+ uses by default a running Excel instance instead of creating a new one,