robust_excel_ole 1.32 → 1.36

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f56e6aaeeeec6c073cc4f871ea99185428523959c420e1165d199792979074c5
-  data.tar.gz: 79dd7f6ea160e0045592a3dd8ae31a5b8a162c71b6986dcbcef157eba54c93b4
+  metadata.gz: 0d53d040d2a0079556bfca8d89a531f65b75f8e27d361378e339d38ac8ec7fdf
+  data.tar.gz: 68658a532b13b21815f61e5ce7a286b8df42693711142ee7ff9c15c26cf6fa07
 SHA512:
-  metadata.gz: 894959ff3e8c48c8413bbb137013cf8ad7612bb991292f1461b1df9b3371d15c16132ecf0df0dbf78403171381064cfb43d9400604bc2155214f8aa2a514ea7c
-  data.tar.gz: 508b37f27ef7c0e554b565f21263386e1b180cb5269f6a843b2da927eaa3f6eebe5a111a362d5dc96de4726a1c3648673b062b02589739eb7e5ff2a0bb7f59cc
+  metadata.gz: '08f8abee9ca47bf37d4d27e3d13ecfcb31f1ae019370450bb052911ccd5a56ec5116c007d1f1475c19a29226857281f7d9d80747c5d2e5a7ac605de5d4d96660'
+  data.tar.gz: 7243013b9b0af1c07c0e0eebb240c448be063d55f0dc5e2e15919df474aec957c444e45211eea4c093288e429111e3057f1860d7cc49ab4ffa5d160744a490cd

data/.gitignore

@@ -9,5 +9,6 @@ doc/*
 *.sublime-workspace
 .yardoc
 TodoList.md
+spec/data/*.xls
 spec/data/*.xls*
 spec/data/workbook_listobjects.xlsx

data/Changelog

@@ -1,6 +1,26 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
+## [1.36] 2021-29-10
+
+### Added
+  - Workbook.open: option if_blocked: :accept
+  - ListRow#methods, respond_to?, alive?
+  - Range#workbook, ListObject#workbook, ListRow#workbook
+  - Workbook#writable=
+
+### Changed
+  - Workbook#open instead of Workbook#reopen
+
+
+## [1.35] 2021-24-07
+
+## [1.34] 2021-21-06
+
+## [1.34] 2021-15-06
+
+## [1.33] 2021-01-06
+
 ## [1.32] 2021-23-04
 
 ### Added
@@ -123,14 +143,14 @@ All notable changes to this project will be documented in this file.
    - Workbook#save, save_as: removed parameter :discoloring
    - RangeOwners#set_namevalue, set_namevalue_glob, Worksheet#set_cellval: 
      removed optional parameter for color 
-   - Workbook#open: removed option :excel => :reserved_new  
+   - Workbook.open: removed option :excel => :reserved_new  
 
 
 ## [1.11]
 
 ### Added
   - Range#==, Worksheet#== 
-  - Workbook#open: options :if_blocked is synonym to :if_obstructed
+  - Workbook.open: options :if_blocked is synonym to :if_obstructed
   - Simplified Code
 
 ## [1.10]

data/README.rdoc

@@ -1,44 +1,19 @@
-= News
-
-== New Interface of #[]
-
-Worksheet#[] now returns a value instead of a range, e.g.
-
-  worksheet[1,1]
-  # => "foo"
-
-Transformation: To yield the range, write range() instead of (). For example,
-
-  worksheet.range(1,1)
-
- or
-
-  worksheet.range([1,1])
-
-This returns the range of cell with address 1,1.
-
-With this new interface, we want to be compatible with the standard syntax of other known Excel libraries, e.g. +spreadsheet+ or +axlsx+.
-
-== Using own WIN32OLE objects
-
-If you use WIN32OLE objects and define your own methods, please use upper-case method names. 
-The reason is that we extend the class WIN32OLE such that RobustExcelOle methods can be applied to WIN32OLE objects, such the RobustExcelOle objects and their wrapped WIN32OLE objects are interchangeable. We want to develop a refinement such that the name space is not being desturbed.
-
 = RobustExcelOle
 
 RobustExcelOle helps controlling Excel. 
 This obviously includes standard tasks like reading and writing Excel workbooks.
+
+RobustExcelOle objects wrap WIN32OLE objects, like workbooks, worksheets and ranges. 
+All applicable VBA methods can be sent to those objects. 
+For solving complex tasks, convenient methods are added.
+
 The gem is designed to manage simultaneously running Excel instances, even with simultanously happening user interactions. 
+It supports handling workbooks across those Excel instances by keeping track of workbooks and instances. Conflicts are managed before Excel notices.
 
 RobustExcelOle deals with various cases of Excel (and user) behaviour, and
 supplies workarounds for some Excel and JRuby bugs. 
 
-It supports handling workbooks across Excel instances by keeping track of workbooks and instances. Conflicts are managed before Excel notices.
-
-Library references are supported.
-
-RobustExcelOle works by sending VBA methods via WIN32OlE. 
-Therefore, it runs on Windows only.
+Because it uses VBA methods, RobustExcelOle runs on Windows only.
 
 == Features
 
@@ -127,27 +102,26 @@ Now we want to write a new value into this cell.
 
   workbook['firstcell'] = "new"
 
-Then we'll save the workbook.
+Then we'll save and close the workbook.
 
   workbook.save
+  workbook.close
 
-=== More features when opening, modifying, creating, saving and closing workbooks
+=== Unobtrusively opening workbooks
 
 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.unobtrusively('spec/data/workbook.xls') do |workbook|
-    # do something
-  end
-
   Workbook.for_modifying('spec/data/workbook.xls') do |workbook|
-    # do something
+    workbook.sheet(1)[1,1] = "bar"
   end
 
   Workbook.for_reading('spec/data/workbook.xls') do |workbook|
-    # do something
+    value = workbook.sheet(1)[1,1]
   end
 
-We can also create a new, empty workbook. 
+=== More features about creating and opening workbooks 
+
+We can create a new, empty workbook. 
 
   Workbook.create('spec/data/new_workbook.xls', visible: true)
 
@@ -157,77 +131,25 @@ Moreover, we can open the workbook using a block, similar to, e.g., +File.open+.
     # do something
   end
 
-Once we have a workbook, we can set some options, e.g.
-
-  workbook.for_this_workbook(visible: true, read_only: false)
-
-We can also open the workbook and provide the options in one step, e.g.
-
-  workbook = Workbook.open('spec/data/workbook.xls', visible: true)
-
-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).
 
-For more details about opening workbooks see {README_open}[https://github.com/Thomas008/robust_excel_ole/blob/master/docs/README_open.rdoc]
- 
-We can do a simple save
-
-  workbook.save
-
-or save the workbook under a different name.
-
-  workbook.save_as('spec/data/new_workbook.xls')
-
-Finally we can close the workbook
-
-  workbook.save
-
-or save and close the workbook in one step.
-
-  workbook.close(if_unsaved: :save)
-
-For more details about saving and closing workbooks see
-{README_save_close}[https://github.com/Thomas008/robust_excel_ole/blob/master/docs/README_save_close.rdoc]
-
-
-=== Using Excel instances
-
-We can start a new Excel instance with
-
-  excel1 = Excel.create
+For more details about opening workbooks see {README_open}[https://github.com/Thomas008/robust_excel_ole/blob/master/docs/README_open.rdoc].
+For saving and closing workbooks see
+{README_save_close}[https://github.com/Thomas008/robust_excel_ole/blob/master/docs/README_save_close.rdoc].
 
-or
-
-  excel1 = Excel.new(reuse: false)
-
-We can also obtain an Excel object by connecting to the already running Excel instance.
-
-  excel2 = Excel.current
-
-or 
-
-  excel2 = Excel.new(reuse: true)  
-
-We close the Excel instance using
-
-  excel1.close
-
-Closed Excel instances can be reopened.
-
-  excel1.recreate(reopen_workbooks: true, visible: true)
+=== Managing conflicts with unsaved and blocking workbooks
 
-Closing all Excel instances is done by
+RobustExcelOle enables processing workbooks, while supporting user's interactions: The commands enable to open, close, reopen, read, modify, write and save Excel workbooks, 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 workbooks 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.
 
-  Excel.close_all(if_unsaved: :forget)
+For example, suppose we 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 already 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 (forgotten) before opening the workbook, e.g.
 
-For hard terminating all Excel processes we can use
+  workbook = Workbook.open('workbook.xls', if_unsaved: :accept)
 
-  Excel.kill_all
+Similarly, if the user has opened a workbook that has the same name but a different path, the conflict can be solved via an option.
 
-For more details about opening Excel instances see {README_excel}[https://github.com/Thomas008/robust_excel_ole/blob/master/docs/README_excel.rdoc]
+  workbook1 = Workbook.open('spec/data/workbook.xls')
+  # do something
+  workbook2 = Workbook.open('spec/data/more/workbook.xls', if_blocked: :forget)
 
 
 === Opening workbooks in several Excel instances
@@ -242,39 +164,20 @@ Now we want to open another workbook in a different Excel instance.
 
   workbook2 = Workbook.open('spec/data/different_workbook.xls', excel: :new)
 
-We can also create a third Excel instance and open another workbook in this instance.
-
-  excel1 = Excel.create
-  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.
 
    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.
+If the 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.
 
   workbook1 = Workbook.open('spec/data/workbook.xls', default: {excel: new})
 
-Without the option +:default+, the workbook can be forced to be opened in the current, new or given Excel instance, no matter if and where it was opened before, e.g.
+Without the option +:default+, the workbook can be forced to be opened in the current, a new or a given Excel instance, no matter if and where it was opened before, e.g.
 
-  workbook2 = Workbook.open('spec/data/workbook.xls', excel: excel1)
+  workbook2 = Workbook.open('spec/data/workbook.xls', excel: new)
 
-=== Managing conflicts with unsaved and blocking workbooks
-
-RobustExcelOle enables processing workbooks, while still supporting user's interactions: The commands enable to open, close, reopen, read, modify, write and save Excel workbooks, 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 workbooks 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 we 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 already 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 (forgotten) before opening the workbook, e.g.
-
-  workbook = 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 can be solved via an option.
-
-  workbook1 = Workbook.open('spec/data/workbook.xls')
-  # do something
-  workbook2 = Workbook.open('spec/data/more/workbook.xls', if_blocked: :forget)
-
-For more details about opening and closing workbooks in Excel instances see {README_open}[https://github.com/Thomas008/robust_excel_ole/blob/master/docs/README_open.rdoc]
+For more details about opening Excel instances see {README_open}[https://github.com/Thomas008/robust_excel_ole/blob/master/docs/README_open.rdoc] and {README_excel}[https://github.com/Thomas008/robust_excel_ole/blob/master/docs/README_excel.rdoc]. 
 
 === Operating on worksheets
 
@@ -286,14 +189,6 @@ We access the first worksheet by
 
   worksheet = workbook.sheet(1)
 
-or 
-
-  worksheet = workbook.sheet('Sheet1')
-
-or
-  
-  worksheet = workbook.first_sheet
-
 We can read and change the worksheet name.
 
   worksheet.name
@@ -305,7 +200,7 @@ We can copy the first worksheet, name it and add it before the third worksheet.
 
   workbook.add_or_copy_sheet(sheet, as: "copied_name, before: workbook.last_sheet)
 
-For more details about processing worksheets see {README_sheet}[https://github.com/Thomas008/robust_excel_ole/blob/master/docs/README_sheet.rdoc]
+For more details about processing worksheets see {README_sheet}[https://github.com/Thomas008/robust_excel_ole/blob/master/docs/README_sheet.rdoc].
 
 === Reading and writing ranges in worksheets
 
@@ -313,24 +208,10 @@ We can define a rectangular range by providing the top left and the bottum down
 
   worksheet.range([1..3,1..4])
 
-We can read the first three cells of the first row
-
-  worksheet.row_range(1, 1..3).values   # => ["foo","workbook","sheet1"]
-
-and the third column
-
-  worksheet.col_range(3).values   # => ["sheet1", 2.0, 4.0]
-
-We can read the first cell, using
-
-  worksheet[1,1].    # => "foo"
-
-or
-
-  worksheet.row_range(1)[0].value    # => "foo"
-
-Then we modify it.
+We can read and modify the first cell, e.g.
 
+  worksheet[1,1]    
+  # => "foo"
   worksheet[1,1] = "hello"
 
 We get the value of a named range 
@@ -343,20 +224,15 @@ and set another value to that range.
 
 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]
 
-
 === List Objects (Tables)
 
-We can define a list object (or table) from scratch
-
-  table = ListObject.new(worksheet, "table 1", [1,1], 3, ["Person","AmountSales"])
-
-or get a given list object in a worksheet given its table number or name.
+We obtain a given list object in a worksheet given its table number or name.
 
   table = worksheet.table(1) 
 
-or
+We can also define a list object from scratch
 
-  table = worksheet.table("table1")
+  table = ListObject.new(worksheet, "table 1", [1,1], 3, ["Person","AmountSales"])
 
 A list row can be accessed by providing either the row number or a key, i.e. hash of column name - value pairs, e.g.
 
@@ -366,18 +242,18 @@ A list row can be accessed by providing either the row number or a key, i.e. has
 
 You can get all or a maximal number of list rows matching the key.
 
-  rows = table[{"Number": 1}, limit: 2]
   rows = table[{"Number": 1}, limit: nil]
+  rows = table[{"Number": 1}, limit: 2]
 
-Now we can set value of a cell of the table with help of methods that are equal to or are underscored variants of the column names, e.g.
+Now we can read and set the value of a cell of the table with help of methods that are underscored variants of the column names, e.g.
 
   row1.person = "John"
 
-or
+or with help of the column name
 
   row1["Person"] = "John"
 
-Similarly you can get the values. We can also read all values in a row.
+We can also read all values in a row.
 
   table[1].to_a
   # => ["John", 40]
@@ -385,57 +261,15 @@ Similarly you can get the values. We can also read all values in a row.
   table[1].to_h
   # => {"Person": "John", "AmountSales": 40}
 
-We can set the values in a whole row.
-
-  table[1].values = ["Herber", 80]
-
-Similarly, we can read and set the values in a whole column, e.g.
-
-  table.column_values("Person")
-  # => ["John", "Peter"]
-
-and 
-
-  table.set_column_values(1, ["Herbert","Paul"])
-
-We can add and delete rows and columns, supplying optionally their name, the position and contents. 
-
-  table.add_column("column_name", 3, ["John", "Paul"])
-  table.add_row(3, ["John", 40, 2, 2004])
-
-  table.delete_column_values("column_name")
-  table[2].delete_values
-
- Finally we can delete empty rows and columns.
-
-  table.delete_empty_rows
-  table.delete_empty_columns
-
-For more details about using and processing list objects see {README_listobjects}[https://github.com/Thomas008/robust_excel_ole/blob/master/docs/README_listobjects.rdoc]
- 
+For more details about using and processing list objects see {README_listobjects}[https://github.com/Thomas008/robust_excel_ole/blob/master/docs/README_listobjects.rdoc].
 
 === More features
 
-1. The method +General.change_current_binding+ allows to change the value of self within the current binding, while preserving the local variables, without starting another repl. Assume, +object+ shall be the self, then you would put
-
-  General.change_current_binding(object)
-
-Without this method, the ruby shell 'pry' allows to change the value of 'self' in the console as well, e.g. 
-
-  object.pry
-
-or
-
-  cd object
-
-However, this command also starts another pry repl (with another binding). Moreover, local variables in the previous binding are forgotten.
-
-
-2. The class Win32Ole is being extended such that RobustExcelOle methods can be applied to WIN32OLE objects. As mentioned above, the RobustExcelOle objects are wrapper of corresponding WIN32OLE objects. So the RobustExcelOle objects and their wrapped WIN32OLE objects are interchangeable. One example would be
+The class WIN32OLE is being extended such that RobustExcelOle methods can be applied to WIN32OLE objects. As mentioned above, the RobustExcelOle objects are wrapper of corresponding WIN32OLE objects. So now the RobustExcelOle objects and their wrapped WIN32OLE objects are interchangeable. One example would be
 
   range.ole_range.copy([4,3])
 
-Likewise it is possible to convert ("type-lift") Win32Ole objects into the corresponding RobustExcelOle object, using the method +to_reo+. It is a refinement of the class WIN32OLE. So you can write
+Likewise it is possible to convert ("type-lift") WIN32OLE objects into the corresponding RobustExcelOle object, using the method +to_reo+. It is a refinement of the class WIN32OLE. So you can write
 
   using ToReoRefinement
 

data/docs/README_excel.rdoc

@@ -1,10 +1,11 @@
-= RobustExcelOle
+== Managing Excel instances
 
-== Creating, using and closing Excel instances
+Details are essentially covered in the ruby documentation of the class
+Excel[https://www.rubydoc.info/gems/robust_excel_ole/RobustExcelOle/Excel].
 
-RobustExcelOle enables simultanously running Excel instances. An Excel application is represented by an Excel object.
+=== Creating, using and closing Excel instances
 
-=== Creating and reusing an Excel instance.
+RobustExcelOle enables simultanously running Excel instances. An Excel application is represented by an Excel object.
 
 You can create a new Excel instance by
 
@@ -168,6 +169,4 @@ This method has the option +:if_unsaved+ as described above. For example, if you
 
 This method kills all Excel instances no matter whether they contain unsaved workbooks.  
 
-== Code
 
-excel.rb[https://github.com/Thomas008/robust_excel_ole/blob/master/lib/robust_excel_ole/excel.rb]

data/docs/README_listobjects.rdoc

@@ -1,7 +1,9 @@
-= RobustExcelOle
-
 == List Objects
 
+A List object in a worksheet represents a table.
+The details are essentially covered in the ruby docmentation of the class
+ListObject[https://www.rubydoc.info/gems/robust_excel_ole/RobustExcelOle/ListObject].
+
 === Creating List Objects
 
 We can define a list object (or table) from scratch.
@@ -54,20 +56,14 @@ or
 or
 
   row1["AmountSales"] = 40
-  
-Similarly you can get the values.
-
-  row1.AmountSales
-  # => 40
 
 or
 
-  row1.amount_sales
-  # => 40
-
-or
+  row1[:AmountSales] = 40
+  
+Similarly you can get the values, e.g.
 
-  row1["AmountSales"]
+  row1.amount_sales
   # => 40
 
 We can also read the values in a whole row.
@@ -170,7 +166,4 @@ You can sort a table according to a given column and sort order, e.g.
 
   table.sort("Person", :ascending)
 
-== Code
-
-listobjects.rb[https://github.com/Thomas008/robust_excel_ole/blob/master/lib/robust_excel_ole/listobjects.rb]
 

data/docs/README_open.rdoc

@@ -1,6 +1,9 @@
-= RobustExcelOle
+== Opening workbooks
 
-=== Opening a workbook.
+The details are essentially covered in the ruby documentation of the 
+class Workbook[https://www.rubydoc.info/gems/robust_excel_ole/RobustExcelOle/Workbook].
+
+=== How to open a workbook
 
 If you want to open a workbook, you can use the methods +open+ or +new+.
   
@@ -36,12 +39,12 @@ The options are the following:
 
 +:if_unsaved+::        specifies behaviour if the workbook was unsaved (default: +:raise+)
 
-+:if_blocked::         specifies behaviour if the workbook is blocked by another book (default: +:raise+)
++:if_blocked+::         specifies behaviour if the workbook is blocked by another book (default: +:raise+)
 
 
 +:read_only+::          opens in read-only mode (default: +false+)
 
-+:check_compatibility:: checks compatibility when saving
++:check_compatibility+:: checks compatibility when saving
 
 +:calculation+::        forces the calculation mode to be manual (:manual) or automatic (:automatic)
 
@@ -49,39 +52,40 @@ The options are the following:
 
 You can use the following abbreviations or synonyms: +:f+ for  +:force+, +:d+ for +:default+, +:e+ for +:excel+, and +:v+ for +:visible+, +:if_obstructed+ for +:if_blocked+. Finally you can leave out the option +:force+ or +:f+.
 
-The option +:excel+ :
+=== The option +:excel+ :
 
 Valid values are : +:current+ (or +:active+ or +:reuse+), +:new+, or a given Excel instance (default: +:current).
 
-The option +:if_unsaved+  : 
+=== The option +:if_unsaved+  : 
 
-If a workbook contains unsaved changes and a new workbook with the same file name shall be opened, then
+If a workbook contains unsaved changes and the workbook shall be re-opened, then
 
-+:raise+::   Raise an exeption. Don't open the workbook.
-+:accept+::  Let the unsaved workbook open.
++:raise+::   Raise an exeption. Leave the unsaved workbook open.
++:accept+::  Leave the unsaved workbook open.
 +:forget+::  Discard any changes and reopen the workbook.
 +:save+::    Save any changes and reopen the workbook
-+:new_excel+:: Open the new workbook in a new Excel instance
++:new_excel+:: Open the workbook in a new Excel instance
 +:alert+::   Give control to Excel.
 
-The option +:if_blocked+ : 
+=== The option +:if_blocked+ : 
 
-If a workbook is open and a new workbook with same name and a different path is open, then
+If a workbook is open and a workbook with same base name but in a different path shall be opened, then the first workbook blocks opening the latter one. In this case:
 
-+:raise+::          Raise an exception. Don't open the workbook.
-+:forget+::         Close the old workbook, open the new workbook.
-+:save+::           Save the old workbook, close it, open the new workbook
-+:close_if_saved+:: Close the old workbook and open the new workbook, if the old workbook is saved, otherwise raise an exception.
++:raise+::          Raise an exception. Don't open the workbook. Leave the blocking workbook open.
++:forget+::         Close the blocking workbook, open the new workbook.
++:accept+::         Leave the blocking workbook open.
++:save+::           Save the blocking workbook, close it, open the new workbook
++:close_if_saved+:: Close the blocking workbook and open the new workbook, if the blocking workbook is saved, otherwise raise an exception.
 +:new_excel+::      Open the new workbook in a new Excel instance.
 
-The option +:if_absent  :
+=== The option +:if_absent+ :
 
 If the Excel file does not exists, then
 
 +:create+::   Create a new Excel file
 +:raise+::    Raise an exception.
   
-Here are a few examples:
+=== 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
 
@@ -129,7 +133,7 @@ If a workbook is open and a workbook with the same name but in different path sh
 
   workbook = Workbook.open('path/workbook.xls', if_blocked: :forget)
 
-Remarks:
+=== Remarks
 
 The methods +open+ and +new+ connect to workbooks opened outside of RobustExcelOle as well.
 
@@ -137,13 +141,18 @@ 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.
 
-=== Reopening a workbook.
+Once we have a workbook, we can set some options, e.g.
+
+  workbook.for_this_workbook(visible: true, read_only: false)
+
+
+=== Reopening a workbook
 
 A special feature of RobustExcelOle is that it allows to reopen workbooks after closing them.
 
   workbook = Workbook.open('spec/data/workbook.xls')
   workbook.close
-  workbook.reopen
+  workbook.open
 
 The closed workbook is now alive again, i.e. is open and responds to Excel methods.
 
@@ -176,7 +185,7 @@ You can also supply a workbook and options, e.g.
 
    new_workbook = Workbook.new(workbook, visible: true)
 
-=== Identity transperence ===
+=== Identity transperence
 
 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. 
 
@@ -245,13 +254,27 @@ This method ensures keeping the save status of the workbook
     # some reading or modifying
   end
 
-=== Checking whether the workbook is alive.
+=== Changing ReadOnly-mode
+
+When you want to change the read-only mode, you can use the method +writable=+. 
+
+  workbook = Workbook('spec/data/workbook.xls')
+  workbook.writable = false
+  workbook.writable
+  # => false
+  workbook.ReadOnly
+  # => true
+  workbook.writable = true
+
+If the workbook is unsaved, use the option +if_unsaved+ as desribed above.
+
+  workbook.writable = false, {if_unsaved: :forget}
+
+=== Checking whether the workbook is alive
 
 The method +alive?+ finds out whether the Excel workbook that is referenced by the Workbook object responds to methods. For example
 
   workbook.alive?
   # => true
 
-== Code
 
-workbook.rb[https://github.com/Thomas008/robust_excel_ole/blob/master/lib/robust_excel_ole/workbook.rb]