robust_excel_ole 1.13 → 1.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f76aadd233f6dd4c2f5d568d54ef10c6c030762544906a3357c7f04464e24846
-  data.tar.gz: 68101beb84d01cd1b2da24c4568a833d5b6d641c5829b3b7e1da793c651a1aa3
+  metadata.gz: 7f98eac7f4995b60c16017d6be170e0621eaf77b708c4f796b4bde1b0bdb17fc
+  data.tar.gz: bdad471c90fbda86803c03860077e29d2eba3583ec94173d782f8f80b1eb3480
 SHA512:
-  metadata.gz: 8b79a216b5460efd0b51ff81c335e53c37d8c7530185838f88e7befc0eacbd686338d7578ffee7db399795427c0983abc091a2c673230e126d01ff335e1cb80f
-  data.tar.gz: 55c8c0bb5a58d2574bf2938333e551e91402e7eb75eb40bc380fc3eee998766aa693f7e4eb5f615ad21f2c9882376259c900b813541547f47b0f3d071121cc10
+  metadata.gz: a8a472ec475629d7f9cb2d6886ed009a23e1a5598ba79152accca7f21dde87b05ff46f4a6f776acc6b75ea21538249df31e94145883946d379e0b71dcdcae05f
+  data.tar.gz: 90aa4909eaec50fc74b57c75ad5112ba4216e49177263532dbf703ad4d3694b5a64f7f4c69613dac528fc9cf7874dae98d39900bef5aa62eee3bfb0a860bc215

data/Changelog

@@ -1,6 +1,49 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
+## [1.18] 2020-30-4
+
+### Added
+  - Workbook#worksheets, worksheets_count
+  - Worksheet#each_value
+  - Range#value, value=
+
+### Changed
+  - Range#initialize: optional paramter worksheet
+
+## [1.17]
+
+### Added
+  - Excel#active_workbook
+
+### Changed
+  - Excel#namevalue, set_namevalue, namevalue_glob, set_namevalue_glob are being removed
+
+## [1.16]
+
+### Added
+   - RangeOwners#set_namevalue, set_namevalue_glob, Worksheet#set_cellval: 
+     optional parameter for color 
+   
+### Changed   
+   - Workbook#color_if_modified removed   
+
+## [1.15]
+
+### Added
+   - Workbook#unobtrusively, Workbook#for_reading, Workbook#for_modifying
+
+### Changed
+   - Workbook.unobtrusively: removed parameter :rw_change_excel
+   
+## [1.14]
+
+  - no interface change
+
+## [1.13]
+
+  - no interface change
+
 ## [1.12]
 
 ### Added
@@ -8,9 +51,10 @@ All notable changes to this project will be documented in this file.
    - Workbook#color_if_modified
 
 ### Changed:
-   - Workbook#save, save_as: no parameter +discoloring
+   - Workbook#save, save_as: removed parameter :discoloring
    - RangeOwners#set_namevalue, set_namevalue_glob, Worksheet#set_cellval: 
-     no optional parameter for color 
+     removed optional parameter for color 
+   - Workbook#open: removed option :excel => :reserved_new  
 
 
 ## [1.11]
@@ -23,7 +67,6 @@ All notable changes to this project will be documented in this file.
 ## [1.10]
 
 ### Added
-  - workarounds for running in Jruby
   - Range,Cell#v
 
 ## [1.9]
@@ -74,7 +117,7 @@ All notable changes to this project will be documented in this file.
   - ReoCommon#namevalue, namevalue_glob, set_namevalue, set_namevalue_glob replace
     set_namevalue replaces set_rangeval, set_namevalue_glob, respectively
 
-## [1.2.1] 2018-9-2
+## [1.2.1] 2018-9-12
 
 ## [1.2] - 2018-11-8
 

data/README.rdoc

@@ -14,10 +14,27 @@ Library references are supported.
 RobustExcelOle works by sending VBA methods via Win32OLE. 
 Therefore, it runs on Windows only.
 
+== Feature list
+
+- opening and processing workbooks across various Excel instances
+- reading and writing workbooks (cells and ranges)
+- reopening and unobtrusively opening workbooks
+- convenient methods for standard tasks (like opening, reading, writing, closing, saving workbooks, naming, adding, and copying ranges and worksheets)
+- dealing with various cases of Excel and user behaviour, e.g. managing conflicts when opening workbooks (e.g. blocking or unsaved workbooks),
+  even with simultanously happening user interactions
+- workarounds for Excel bugs and JRuby bugs
+- various workbook formats, e.g. .xlsx, .xls, .xlsm are supported
+- library references are supported
+- console for convenient usage
+
+== What's new?
+
+  - removing methods to operate on ranges directly from an Excel instance. However, you can use the method Excel.active_workbook to do so.
+  See ChangeLogs.
 
 == Requirements
 
-  Ruby 2.1 or higher. Most functions run on Ruby 1.8.6, too.
+  Ruby 2.1 or higher.
 
 == Installation
 
@@ -44,11 +61,7 @@ and go into the path of the gem 'robust_excel_ole'. There you start the console
 
   reo
 
-or
-
-  jreo
-
-depending on whether you are using ruby or jruby.
+If you don't want to use a version manager to switch between ruby and jruby, you can apply the command +reo+ when using ruby, and +jreo+ when using jruby.
 
 The call of the console will include RobustExcelOle for you.
 
@@ -62,24 +75,21 @@ Let's open a workbook.
 
   workbook = Workbook.open 'spec/data/workbook.xls'
 
-Now we have a Workbook object that wraps a win32ole object. That is, you can send any win32ole (VBA) method to it. See 
+Now we have a Workbook object that wraps a WIN32OLE object. That is, you can send any WIN32OLE (VBA) method to it. See 
 https://docs.microsoft.com/en-us/office/vba/api/excel.workbook#methods.
 
-For example, you can determine the name and the visible status of the workbook.
+For example, you can determine the name of the workbook.
 
   workbook.Name 
   # => "workbook.xls"
 
-  workbook.Visible
-  # => false
-
 For some common tasks and for considering various complex cases of Excel and user behaviour, more convenient methods are implemented. For example, RobustExcelOle provides methods for reading and writing the contents of ranges, for opening, saving, closing, reopening and unobtrusively opening workbooks, and for setting options.
 
 First we want to make the workbook visible.
 
   workbook.visible = true
 
-This method makes both the Excel instance and the window of the Workbook-win32ole-object visible.
+This method makes both the Excel instance and the window of the Workbook WIN32OLE object visible.
 
 Let's read the value of a named cell.
 
@@ -94,21 +104,13 @@ Then we'll save the workbook.
 
   workbook.save
 
-Finally we want to close the workbook.
-
-  workbook.close
-
-One special feature of RobustExcelOle is that it enables reopening workbooks.
-
-  workbook.reopen
+=== More features when opening, modifying, creating, saving and closing workbooks
 
-The workbook is now open again and ready for applying further operations, e.g.
+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.
 
-  workbook['firstcell'] = "another_value"
-  workbook.save
-  workbook.close
-
-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 (the Workbook object remembers its properties).
+  Workbook.unobtrusively('spec/data/workbook.xls') do |workbook|
+    # do something
+  end
 
   Workbook.for_modifying('spec/data/workbook.xls') do |workbook|
     # do something
@@ -122,9 +124,7 @@ You can also create a new, empty workbook.
 
   Workbook.create('spec/data/new_workbook.xls', :visible => true)
 
-=== More features when opening, modifying, creating saving and closing workbooks
-
-We can open the workbook using a block, similar to, e.g., +File.open+. 
+Moreover, you can open the workbook using a block, similar to, e.g., +File.open+. 
 
   Workbook.open('spec/data/workbook.xls') do |workbook|
     # do something
@@ -142,7 +142,7 @@ or, using abbreviations,
 
   workbook = Workbook.open('spec/data/workbook.xls', :v => true)
 
-Note that Workbook.open can also connect to workbooks which were not opened via RobustExcelOle (but had been opened before by some user).
+Note that +Workbook.open+ can also connect to workbooks which were not opened via RobustExcelOle (but had been opened before by some user).
 
 For more details about opening workbooks see {README_open}[https://github.com/Thomas008/robust_excel_ole/blob/master/docs/README_open.rdoc]
  
@@ -154,7 +154,11 @@ or save the workbook under a different name.
 
   workbook.save_as('spec/data/new_workbook.xls')
 
-Finally we can save and close the workbook in one step.
+Finally we can close the workbook
+
+  workbook.save
+
+or save and close the workbook in one step.
 
   workbook.close(:if_unsaved => :save)
 
@@ -196,7 +200,8 @@ For hard terminating all Excel processes we can use
 
   Excel.kill_all
 
-For more details about creating Excel instances see README_excel[https://github.com/Thomas008/robust_excel_ole/blob/master/README/README_excel_rdoc]
+For more details about opening Excel instances see {README_excel}[https://github.com/Thomas008/robust_excel_ole/blob/master/docs/README_excel.rdoc]
+
 
 === Opening workbooks in several Excel instances
 
@@ -213,12 +218,12 @@ Now we want to open another workbook in a different Excel instance.
 We can also create a third Excel instance and open another workbook in this instance.
 
   excel1 = Excel.create
-  book3 = Workbook.open('spec/data/another_workbook.xls', :excel => excel1)
+  workbook3 = Workbook.open('spec/data/another_workbook.xls', :excel => excel1)
 
 A workbook is opened by default in the Excel instance where it was open before most recently.
 
-   book1.close
-   book1 = Workbook.open('spec/data/workbook.xls') 
+   workbook1.close
+   workbook1 = Workbook.open('spec/data/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.
 
@@ -252,22 +257,22 @@ Assume we have opened a workbook
 
 We access the first worksheet by
 
-  sheet = workbook.sheet(1)
+  worksheet = workbook.sheet(1)
 
 or 
 
-  sheet = workbook.sheet('Sheet1')
+  worksheet = workbook.sheet('Sheet1')
 
 or
   
-  sheet = workbook.first_sheet
+  worksheet = workbook.first_sheet
 
 We can read and change the worksheet name.
 
-  sheet.name
+  worksheet.name
   # => "Sheet1"
 
-  sheet.name = "new_sheet"
+  worksheet.name = "new_sheet"
 
 We can copy the first worksheet, name it and add it before the third worksheet.
 
@@ -279,35 +284,35 @@ For more details about processing worksheets see {README_sheet}[https://github.c
 
 We can define a rectangular range by providing the top left and the bottum down cell.
 
-  sheet.range([1..3,1..4])
+  worksheet.range([1..3,1..4])
 
 We can read the first three cells of the first row
 
-  sheet.row_range(1, 1..3).values   # => ["foo","workbook","sheet1"]
+  worksheet.row_range(1, 1..3).values   # => ["foo","workbook","sheet1"]
 
 and the third column
 
-  sheet.col_range(3).values   # => ["sheet1", 2.0, 4.0]
+  worksheet.col_range(3).values   # => ["sheet1", 2.0, 4.0]
 
 We can read the first cell, using
 
-  sheet[1,1].value    # => "foo"
+  worksheet[1,1].value    # => "foo"
 
 or
 
-  sheet.row_range(1)[0].value    # => "foo"
+  worksheet.row_range(1)[0].value    # => "foo"
 
 Then we modify it.
 
-  sheet[1,1] = "hello"
+  worksheet[1,1] = "hello"
 
 We get the value of a named range 
 
-  sheet["firstcell"]    # => "hello"
+  worksheet["firstcell"]    # => "hello"
 
 and set another value to that range.
 
-  sheet["firstcell"] = "new_value"
+  worksheet["firstcell"] = "new_value"
 
 For more details about reading and writing contents of cells and ranges see {README_ranges}[https://github.com/Thomas008/robust_excel_ole/blob/master/docs/README_ranges.rdoc]
 

data/docs/README_excel.rdoc

@@ -26,7 +26,7 @@ Options of the methods +create+ and +new+ are +:reuse+ (+true+, +false+), +:visi
 
 The option +:calculation+ specifies, whether the calculation mode is being forced to be manual (:manual), automatic (+:automatic+) or is not being forced (+nil+).
 
-You can also promote an Excel instance represented as WIN32OLE object to an Excel object.
+You can also type-lift an Excel instance represented as WIN32OLE object to an Excel object.
 
   excel = Excel.new(win32ole_object, :visible => true)
 
@@ -110,7 +110,7 @@ You can yield an array of all Workbook objects of an Excel instance.
 
 You can access all Workbook objects by using the methods Excel#each_workbook and Excel#each_workbook_with_index. Here are some examples:
   
-  excel.each_workook {|w| puts w.filename}
+  excel.each_workbook {|w| puts w.filename}
 
 and
 
@@ -124,6 +124,12 @@ or, with a block,
 
   excel.each_workbook(:visible => true) {|w| puts w}
 
+=== Accessing the active workbook
+
+You can operate on the active workbook with help of the method Workbook#active_workbook, e.g.
+
+  workbook = excel.active_workbook
+
 === Bringing an Excel instance to the foreground
 
   excel1.focus
@@ -146,7 +152,7 @@ Closed Excel instances can also be reopened. This includes reopening all workboo
   excel.close
   excel.recreate
 
-The options are :reopen_workbooks, :visible and :displayalerts.
+The options are +:reopen_workbooks+, +:visible+ and +:displayalerts+.
 
   excel.recreate(:reopen_workbooks => true, :visible => true, :displayalerts => true)
 

data/docs/README_open.rdoc

@@ -2,9 +2,9 @@
 
 === Opening a workbook.
 
-If you want to open a workbook, use
+If you want to open a workbook, you can use the methods +open+ or +new+.
   
-  book = Workbook.open('spec/data/workbook.xls')
+  workbook = Workbook.open('spec/data/workbook.xls')
 
 Once you have got an Workbook object, you can apply all VBA methods that you would apply to a VBA Workbook object
 (see https://docs.microsoft.com/en-us/office/vba/api/excel.workbook#methods).
@@ -46,7 +46,7 @@ You can use the following abbreviations or synonyms: +:f+ for  +:force+, +:d+ fo
 
 The option +:excel+ :
 
-Valid values are : +:current+ (or +:active+ or +:reuse+), +:new+, +:reserved_new+, or a given Excel instance (default: +:current).
+Valid values are : +:current+ (or +:active+ or +:reuse+), +:new+, or a given Excel instance (default: +:current).
 
 The option +:if_unsaved+  : 
 
@@ -80,32 +80,28 @@ 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 = Workbook.open('spec/data/workbook.xls', :default => {:excel => :current})
+  workbook = Workbook.open('spec/data/workbook.xls', :default => {:excel => :current})
 
 or
   
-  book = Workbook.open('spec/data/workbook.xls')
+  workbook = Workbook.open('spec/data/workbook.xls')
 
 In case you want to open such a workbook in a new Excel instance, then use
 
-  book = Workbook.open('spec/data/workbook.xls', :default => {:excel => :new})
-
-You can also open the workbook in a separate, reserved Excel instance.
-
-  book = Workbook.open('spec/data/workbook.xls', :default => {:excel => :reserved_new})
+  workbook = Workbook.open('spec/data/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 = Workbook.open('spec/data/workbook.xls', :force => {:excel => :new})
+  workbook = Workbook.open('spec/data/workbook.xls', :force => {:excel => :new})
 
 For simplicity, you can also leave out the +:force+ option (but not the +:default+ option).
 
-  book = Workbook.open('spec/data/workbook.xls', :excel => :new)
+  workbook = Workbook.open('spec/data/workbook.xls', :excel => :new)
 
 You can also specify an Excel instance
 
   excel1 = Excel.create
-  book = Workbook.open('spec/data/workbook.xls', :excel => excel1)
+  workbook = Workbook.open('spec/data/workbook.xls', :excel => excel1)
 
 If you want to open the workbook and make its window visible, then use
 
@@ -114,22 +110,24 @@ If you want to open the workbook and make its window visible, then use
 Notice, that when the workbook is visible, the DisplayAlerts of the respective Excel instance is true, if not explicitely DisplayAlerts is set to false in this Excel instance.
 You can combine options, e.g. 
 
-  book = Workbook.open('spec/data/workbook.xls', :excel => :new, :visible => true, :default => {:excel => excel1})
+  workbook = Workbook.open('spec/data/workbook.xls', :visible => true, :default => {:excel => excel1})
 
 You can use the abbreviations, e.g. in this case
 
-  book = Workbook.open('spec/data/workbook.xls', :e => :new, :v => true, :d => {:e => excel1})  
+  workbook = Workbook.open('spec/data/workbook.xls', :v => true, :d => {:e => excel1})  
 
 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 = Workbook.open('spec/data/workbook.xls', :if_unsaved => :accept)
+  workbook = Workbook.open('spec/data/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_blocked+ handles this situation, e.g.
 
-  book = Workbook.open('path/workbook.xls', :if_blocked => :forget)
+  workbook = Workbook.open('path/workbook.xls', :if_blocked => :forget)
 
 Remarks:
 
+The methods +open+ and +new+ connect to workbooks opened outside of RobustExcelOle as well.
+
 Opening linked workbooks for EXCEL 2007 is supported
 
 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.
@@ -138,23 +136,58 @@ Doing updating links seems to be dependent on calculation mode: updates happen,
 
 A special feature of RobustExcelOle is that it allows to reopen workbooks after closing them.
 
-  book = Workbook.open('spec/data/workbook.xls')
-  book.close
-  book.reopen
+  workbook = Workbook.open('spec/data/workbook.xls')
+  workbook.close
+  workbook.reopen
 
 The closed workbook is now alive again, i.e. is open and responds to Excel methods.
 
-Technically, this feature is implemented in such way, that a Workbook object is a proxy of an Excel workbook. A Workbook object is defined by the full workbook name and the Excel instance in which it is opened. RobustExcelOle ensures identity transparency which means that the same Workbook objects refer to the same workbooks, and vice versa.
+=== Type-lifting WIN32OLE objects to RobustExcelOle objects
+
+Type-lifting means here: enriching a given object of a certain class by properties and methods of another class. 
+The method +General.to_reo+ enables type-lifting WIN32OLE objects to RobustExcelOle objects, in the sense that the attributes and methods of RobustExcelOle can be applied to these objects. For example, assume we have a WIN32OLE workbook +win32ole_workbook+:
+
+  win32ole_workbook.to_class
+  => WIN32OLE
+
+This object can be type-lifted to a RobustExcelOle workbook.
+
+  workbook = win32ole_workbook.to_reo
+
+  workbook.to_class
+  => RobustExcelOle::Workbook
+
+Similarly, Excel, Worksheet, and Range WIN32OLE objects can be type-lifted to corresponding RobustExcelOle objects. 
+
+The method +to_reo+ uses the method +new+. You can apply the method +new+ directly.
+
+  workbook = Workbook.new(win32ole_workbook)
+
+You can supply options, e.g. +:visible+.
+
+   workbook = Workbook.new(win32ole_workbook, :visible => true) 
+
+You can also supply a workbook and options, e.g.
+
+   new_workbook = Workbook.new(workbook, :visible => true)
 
-=== Promoting a workbook to a Workbook object
+=== Identity transperence ===
 
-A Workbook object can be created when giving an Excel workbook.
+A RobustExcelOle Workbook object is a proxy of an Excel WIN32OLE workbook. A Workbook object is defined by the full workbook name and the Excel instance in which it is opened. RobustExcelOle ensures identity transparency which means that identical Workbook objects refer to identical Excel workbooks, and vice versa. Identity transperence ensures that, no matter how a Workbook object was created - by filename or by type-lifting an Excel workbook - two Workbook objects are identical, if and only if the Excel workbooks, they are referring to, are identical. 
 
-   book = Workbook.new(win32ole_workbook)
+Similarly, each Excel, Worksheet and a Range object in RobustExcelOle is a proxy of a corresponding Excel, Worksheet and a Range object in WIN32OLE. For these objects identity transperence holds as well.
 
-Note that only a restricted number of options can be considered, e.g. +:visible+
+=== Opening workbooks given a network path and a hostname share path ===
 
-   book = Workbook.new(win32ole_workbook, :visible => true)
+RobustExcelOle allows opening workbooks via a network path starting with a drive letter different from the default drive (mostly 'C'), e.g. 
+
+  workbook = Workbook.open('N:/data workbook.xls')
+
+Likewise the corresponding hostname share path can be used, starting with '//', e.g.
+
+  workbook = Workbook.open("//DESKTOP-A5D5GJ5/spec/data/workbook.xls")
+
+where 'DESKTOP-A5D5GJ5' shall be the hostname, and 'data' be the share.
 
 === Unobtrusively modifying a workbook
 
@@ -162,48 +195,57 @@ The method +unobtrusively+ enables the user to read or modify a workbook, no mat
 
 Options are the following:
 
-+:if_closed+:: +:current+ (or +:active, or +:reuse+:): (default) : open a closed workbook in the Excel instance where it was opened most recently, if such an Excel instance exists, otherwise open it in the current (first opened) Excel instance
-               
++:if_closed+:: the Excel instance in which to open the workbook, if it was closed (default: +:current+). (Note: this option works workbooks opened via RobustExcelOle only.)
+
 +:read_only+:: Whether the workbook shall be forced to be open in ReadOnly mode
 +:writable+::  Whether changes in the workbook shall be saved
 
-+:rw_change_excel+::  Excel instance in which the workbook with the
-                      changed read-write permissions shall be opened  
-                      :current (default), :new or an Excel instance                   
-
-+:keep_open+::       Whether the workbook shall be open after unobtrusively opening (default: false)
++:keep_open+:: Whether the workbook shall be open after unobtrusively opening (default: false)
 
+There are the class method and the instance method of +unobtrusively+. Here is an example of the class method:
 
   Workbook.unobtrusively('spec/data/workbook.xls') do |book|
     # some modification
-    sheet = book[0]
-    sheet[1,1] = "c" 
+    book.sheet(1)[1,1] = "c" 
   end
-  
-The methods +for_reading+ and +for_modifying+ indicate unobtrusively reading or modifying.
+
+Here is an example of the instance method:
+
+  book.unobtrusively do
+    # some modification
+    book.sheet(1)[1,1] = "c" 
+  end
+       
+The methods +for_reading+ and +for_modifying+ indicate unobtrusively reading or modifying. 
 
   Workbook.for_modifying('spec/data/workbook.xls') do |book|
     # some modification
-    sheet = book[0]
-    sheet[1,1] = "c" 
+    book.sheet(1)[1,1] = "c"
   end
 
-Note, that the methods +unobtrusively+, +for_reading+ and +for_modifying+ work not only for workbooks opened via RobustExcelOle, but do also connect to workbooks opened outside RobustExcelOle.
+An example of the instance method would be
+
+  book.for_modifying do
+    # some modification
+    book.sheet(1)[1,1] = "c"
+  end
+  
+Note, that the methods +unobtrusively+, +for_reading+ and +for_modifying+ work not only for workbooks opened via RobustExcelOle, but connect to workbooks opened outside RobustExcelOle as well.
 
 === Retaining the saved-status
 
 This method ensures keeping the save status of the workbook
 
-  book = Workbook.open('spec/data/workbook.xls')
-  book.retain_saved do
+  workbook = Workbook.open('spec/data/workbook.xls')
+  workbook.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 Workbook object responds to methods.
+The method +alive?+ finds out whether the Excel workbook that is referenced by the Workbook object responds to methods. For example
 
-  book.alive?
+  workbook.alive?
   # => true
 
 == Code