robust_excel_ole 1.14 → 1.18.1

data/lib/robust_excel_ole/general.rb

@@ -3,24 +3,47 @@
 module General
 
   IS_JRUBY_PLATFORM = (RUBY_PLATFORM =~ /java/)
-  JRUBY_BUG_CONNECT      = IS_JRUBY_PLATFORM && true
-  JRUBY_BUG_COPYSHEETS   = IS_JRUBY_PLATFORM && true
-  JRUBY_BUG_ERRORMESSAGE = IS_JRUBY_PLATFORM && true
-  JRUBY_BUG_CONNECTEXCEL = IS_JRUBY_PLATFORM && true
-  JRUBY_BUG_RANGES       = IS_JRUBY_PLATFORM && true
-
+  ::EXPANDPATH_JRUBY_BUG   = IS_JRUBY_PLATFORM && true
+  ::CONNECT_JRUBY_BUG      = IS_JRUBY_PLATFORM && true
+  ::COPYSHEETS_JRUBY_BUG   = IS_JRUBY_PLATFORM && true
+  ::ERRORMESSAGE_JRUBY_BUG = IS_JRUBY_PLATFORM && true
+  ::CONNECT_EXCEL_JRUBY_BUG      = IS_JRUBY_PLATFORM && true
+  ::RANGES_JRUBY_BUG       = IS_JRUBY_PLATFORM && true
+
+  @private
+  def network2hostnamesharepath(filename)
+    network = WIN32OLE.new('WScript.Network')
+    drives = network.enumnetworkdrives
+    drive_letter, filename_after_drive_letter = filename.split(':') 
+    # if filename starts with a drive letter not c and this drive exists,
+    # then determine the corresponding host_share_path
+    default_drive = File.absolute_path(".")[0]
+    if drive_letter != default_drive && drive_letter != filename  
+      for i in 0 .. drives.Count-1
+        next if i % 2 == 1
+        if drives.Item(i).gsub(':','') == drive_letter
+          hostname_share = drives.Item(i+1)  #.gsub('\\','/').gsub('//','')
+          break
+        end
+      end
+      hostname_share + filename_after_drive_letter if hostname_share
+    else
+      return filename
+    end
+  end
 
   # @private
-  def absolute_path(file) 
+  def absolute_path(file)     
+    file[0,2] = './' if ::EXPANDPATH_JRUBY_BUG && file  =~ /[A-Z]:[^\/]/
     file = File.expand_path(file)
     file = RobustExcelOle::Cygwin.cygpath('-w', file) if RUBY_PLATFORM =~ /cygwin/
     WIN32OLE.new('Scripting.FileSystemObject').GetAbsolutePathName(file).tr('/','\\')
   end
 
   # @private
-  def canonize(filename)   
+  def canonize(filename)
     raise TypeREOError, "No string given to canonize, but #{filename.inspect}" unless filename.is_a?(String)
-
+    filename = network2hostnamesharepath(filename)
     normalize(filename).downcase
   end
 
@@ -72,26 +95,28 @@ end
 
 # @private
 class WIN32OLE
-
-  include RobustExcelOle
   
-  # promoting WIN32OLE objects to RobustExcelOle objects
+  # type-lifting WIN32OLE objects to RobustExcelOle objects
   def to_reo
-    class2method = [{Excel => :Hwnd}, {Workbook => :FullName}, {Worksheet => :Copy}, {Range => :Address}]
+    class2method = [{Excel => :Hwnd}, {Workbook => :FullName}, {Worksheet => :Copy}, {RobustExcelOle::Range => :Row}]
     class2method.each do |element|
       classname = element.first.first
       method = element.first.last
       begin
         self.send(method)
-        return classname.new(self)
+        if classname == RobustExcelOle::Range && self.Rows.Count == 1 && self.Columns.Count == 1
+          return Cell.new(self)
+        else
+          return classname.new(self)
+        end
       rescue
         next
       end
     end
+    raise TypeREOError, "given object cannot be type-lifted to a RobustExcelOle object"
   end
 end
 
-
 # @private
 class ::String 
   def / path_part

data/lib/robust_excel_ole/range.rb

@@ -1,4 +1,5 @@
 # -*- coding: utf-8 -*-
+
 module RobustExcelOle
 
   # This class essentially wraps a Win32Ole Range object. 
@@ -6,28 +7,44 @@ module RobustExcelOle
   # that you would apply for a Range object. 
   # See https://docs.microsoft.com/en-us/office/vba/api/excel.worksheet#methods
 
-  class Range < REOCommon
+  class Range < VbaObjects
     include Enumerable
     attr_reader :ole_range
     attr_reader :worksheet
 
-    def initialize(win32_range)
+    def initialize(win32_range, worksheet = nil)
       @ole_range = win32_range
-      @worksheet = worksheet_class.new(self.Parent)
+      @worksheet = worksheet ? worksheet : worksheet_class.new(self.Parent)
+      #@worksheet = worksheet_class.new(self.Parent)
     end
 
     def each
-      @ole_range.each do |row_or_column|
-        yield RobustExcelOle::Cell.new(row_or_column)
+      @ole_range.each_with_index do |ole_cell, index|
+        yield cell(index){ole_cell}
       end
     end
 
+    def [] index
+      cell(index) {
+        @ole_range.Cells.Item(index + 1)
+      }
+    end
+
+  private
+
+    def cell(index)
+      @cells ||= []
+      @cells[index + 1] ||= RobustExcelOle::Cell.new(yield,@worksheet)
+    end
+
+  public
+
     # returns flat array of the values of a given range
     # @params [Range] a range
     # @returns [Array] the values
     def values(range = nil)
       #result = map { |x| x.Value }.flatten
-      result_unflatten = if !JRUBY_BUG_RANGES
+      result_unflatten = if !::RANGES_JRUBY_BUG
         map { |x| x.v }
       else
         self.v
@@ -44,11 +61,11 @@ module RobustExcelOle
 
     def v
       begin
-        if !JRUBY_BUG_RANGES
+        if !::RANGES_JRUBY_BUG
           self.Value
         else
           address_r1c1 = self.AddressLocal(true,true,XlR1C1)
-          row, col = Address.int_range(address_r1c1)
+          row, col = address_tool.as_integer_ranges(address_r1c1)
           values = []
           row.each do |r|
             values_col = []
@@ -65,11 +82,11 @@ module RobustExcelOle
 
     def v=(value)
       begin
-        if !JRUBY_BUG_RANGES
+        if !::RANGES_JRUBY_BUG
           ole_range.Value = value
         else
           address_r1c1 = ole_range.AddressLocal(true,true,XlR1C1)
-          row, col = Address.int_range(address_r1c1)
+          row, col = address_tool.as_integer_ranges(address_r1c1)
           row.each_with_index do |r,i|
             col.each_with_index do |c,j|
               ole_range.Cells(i+1,j+1).Value = (value.respond_to?(:first) ? value[i][j] : value)
@@ -82,10 +99,8 @@ module RobustExcelOle
       end
     end
 
-    def [] index
-      @cells = []
-      @cells[index + 1] = RobustExcelOle::Cell.new(@ole_range.Cells.Item(index + 1))
-    end
+    alias_method :value, :v
+    alias_method :value=, :v=
 
     # copies a range
     # @params [Address or Address-Array] address or upper left position of the destination range
@@ -115,8 +130,7 @@ module RobustExcelOle
           { }
         end
       end
-      rows, columns = Address.int_range(dest_address)
-      #dest_sheet = @worksheet if dest_sheet == :__not_provided
+      rows, columns = address_tool.as_integer_ranges(dest_address)
       dest_address_is_position = (rows.min == rows.max && columns.min == columns.max)
       dest_range_address = if (not dest_address_is_position) 
           [rows.min..rows.max,columns.min..columns.max]
@@ -168,7 +182,7 @@ module RobustExcelOle
     # @options [Worksheet] the destination worksheet
     # @options [Hash] options: :transpose, :values_only
     def copy_special(dest_address, dest_sheet = :__not_provided, options = { })
-      rows, columns = Address.int_range(dest_address)
+      rows, columns = address_tool.as_integer_ranges(dest_address)
       dest_sheet = @worksheet if dest_sheet == :__not_provided
       dest_address_is_position = (rows.min == rows.max && columns.min == columns.max)
       dest_range_address = if (not dest_address_is_position) 
@@ -220,6 +234,11 @@ module RobustExcelOle
         self.Address == other_range.Address 
     end
 
+    # @private
+    def excel
+      @worksheet.workbook.excel
+    end
+
     # @private
     def self.worksheet_class   
       @worksheet_class ||= begin
@@ -237,10 +256,9 @@ module RobustExcelOle
 
   private
 
-    # @private
     def method_missing(name, *args) 
       if name.to_s[0,1] =~ /[A-Z]/
-        if JRUBY_BUG_ERRORMESSAGE
+        if ::ERRORMESSAGE_JRUBY_BUG
           begin
             @ole_range.send(name, *args)
           rescue Java::OrgRacobCom::ComFailException 
@@ -258,4 +276,9 @@ module RobustExcelOle
       end
     end
   end
+
+  # @private
+  class RangeNotCopied < MiscREOError              
+  end
+
 end

data/lib/robust_excel_ole/range_owners.rb

@@ -2,7 +2,7 @@
 
 module RobustExcelOle
 
-  class RangeOwners < REOCommon
+  class RangeOwners < VbaObjects
 
     # returns the contents of a range with given name
     # if the name could not be found or the value could not be determined,
@@ -22,12 +22,13 @@ module RobustExcelOle
         raise
       end
       ole_range = name_obj.RefersToRange
+      worksheet = self if self.is_a?(Worksheet)
       value = begin
         #name_obj.RefersToRange.Value
-        if !JRUBY_BUG_RANGES       
+        if !::RANGES_JRUBY_BUG       
           ole_range.Value
         else
-          values = RobustExcelOle::Range.new(ole_range).v
+          values = RobustExcelOle::Range.new(ole_range, worksheet).v
           (values.size==1 && values.first.size==1) ? values.first.first : values
         end
       rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException 
@@ -39,10 +40,10 @@ module RobustExcelOle
           #sheet.Evaluate(name_obj.Name).Value
           # does it result in a range?
           ole_range = sheet.Evaluate(name_obj.Name)
-          if !JRUBY_BUG_RANGES
+          if !::RANGES_JRUBY_BUG
             ole_range.Value
           else
-            values = RobustExcelOle::Range.new(ole_range).v
+            values = RobustExcelOle::Range.new(ole_range, worksheet).v
             (values.size==1 && values.first.size==1) ? values.first.first : values
           end
         rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException 
@@ -61,7 +62,8 @@ module RobustExcelOle
     # sets the contents of a range
     # @param [String]  name  the name of a range
     # @param [Variant] value the contents of the range
-    def set_namevalue_glob(name, value, opts = { })  # opts is deprecated
+    # @option opts [Symbol] :color the color of the cell when set
+    def set_namevalue_glob(name, value, opts = { }) 
       begin
         name_obj = begin
           name_object(name)
@@ -69,13 +71,12 @@ module RobustExcelOle
           raise
         end        
         ole_range = name_object(name).RefersToRange
-        workbook.color_if_modified = opts[:color] unless opts[:color].nil?
-        ole_range.Interior.ColorIndex = workbook.color_if_modified unless workbook.color_if_modified.nil?
-        if !JRUBY_BUG_RANGES
+        ole_range.Interior.ColorIndex = opts[:color] unless opts[:color].nil?
+        if !::RANGES_JRUBY_BUG
           ole_range.Value = value
         else
           address_r1c1 = ole_range.AddressLocal(true,true,XlR1C1)
-          row, col = Address.int_range(address_r1c1)
+          row, col = address_tool.as_integer_ranges(address_r1c1)
           row.each_with_index do |r,i|
             col.each_with_index do |c,j|
               ole_range.Cells(i+1,j+1).Value = (value.respond_to?(:first) ? value[i][j] : value )
@@ -105,11 +106,12 @@ module RobustExcelOle
         raise NameNotFound, "name #{name.inspect} not in #{self.inspect}"
       end
       begin
+        worksheet = self if self.is_a?(Worksheet)
         #value = ole_range.Value
-        value = if !JRUBY_BUG_RANGES
+        value = if !::RANGES_JRUBY_BUG
           ole_range.Value
         else
-          values = RobustExcelOle::Range.new(ole_range).v
+          values = RobustExcelOle::Range.new(ole_range, worksheet).v
           (values.size==1 && values.first.size==1) ? values.first.first : values
         end
       rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException 
@@ -127,21 +129,21 @@ module RobustExcelOle
     # assigns a value to a range given a locally defined name
     # @param [String]  name   the name of a range
     # @param [Variant] value  the assigned value   
-    def set_namevalue(name, value, opts = { })  # opts is deprecated
+    # @option opts [Symbol] :color the color of the cell when set
+    def set_namevalue(name, value, opts = { })  
       begin
-        return set_namevalue_glob(name, value, opts) if self.is_a?(Workbook)  # opts deprecated
+        return set_namevalue_glob(name, value, opts) if self.is_a?(Workbook) 
         ole_range = self.Range(name)
-      rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException
+      rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException, VBAMethodMissingError
         raise NameNotFound, "name #{name.inspect} not in #{self.inspect}"
       end
       begin
-        workbook.color_if_modified = opts[:color] unless opts[:color].nil?
-        ole_range.Interior.ColorIndex = workbook.color_if_modified unless workbook.color_if_modified.nil?
-        if !JRUBY_BUG_RANGES
+        ole_range.Interior.ColorIndex = opts[:color] unless opts[:color].nil?
+        if !::RANGES_JRUBY_BUG
           ole_range.Value = value
         else
           address_r1c1 = ole_range.AddressLocal(true,true,XlR1C1)
-          row, col = Address.int_range(address_r1c1)
+          row, col = address_tool.as_integer_ranges(address_r1c1)
           row.each_with_index do |r,i|
             col.each_with_index do |c,j|
               ole_range.Cells(i+1,j+1).Value = (value.respond_to?(:first) ? value[i][j] : value)
@@ -180,10 +182,11 @@ module RobustExcelOle
     # @return [Range] a range
     def range(name_or_address, address2 = :__not_provided)
       begin
+        worksheet = self if self.is_a?(Worksheet)
         if address2 == :__not_provided
           range = if name_or_address.is_a?(String)
             begin
-              RobustExcelOle::Range.new(name_object(name_or_address).RefersToRange) 
+              RobustExcelOle::Range.new(name_object(name_or_address).RefersToRange, worksheet) 
             rescue NameNotFound
               nil
             end
@@ -192,8 +195,8 @@ module RobustExcelOle
         if self.is_a?(Worksheet) && (range.nil? || (address2 != :__not_provided))
           address = name_or_address
           address = [name_or_address,address2] unless address2 == :__not_provided         
-          self.Names.Add('__dummy001',nil,true,nil,nil,nil,nil,nil,nil,'=' + Address.r1c1(address))          
-          range = RobustExcelOle::Range.new(name_object('__dummy001').RefersToRange)
+          self.Names.Add('__dummy001',nil,true,nil,nil,nil,nil,nil,nil,'=' + address_tool.as_r1c1(address))          
+          range = RobustExcelOle::Range.new(name_object('__dummy001').RefersToRange, worksheet)
           self.Names.Item('__dummy001').Delete
           workbook = self.is_a?(Workbook) ? self : self.workbook
           workbook.save
@@ -216,7 +219,7 @@ module RobustExcelOle
     def add_name(name, addr, addr_deprecated = :__not_provided)
       addr = [addr,addr_deprecated] unless addr_deprecated == :__not_provided
       begin       
-        self.Names.Add(name, nil, true, nil, nil, nil, nil, nil, nil, '=' + Address.r1c1(addr))
+        self.Names.Add(name, nil, true, nil, nil, nil, nil, nil, nil, '=' + address_tool.as_r1c1(addr))
       rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException
         raise RangeNotEvaluatable, "cannot add name #{name.inspect} to range #{addr.inspect}"
       end
@@ -257,13 +260,13 @@ module RobustExcelOle
       rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException
         raise UnexpectedREOError, "name error in #{File.basename(self.stored_filename).inspect}"
       end
-    end
+    end   
 
   private
 
     def name_object(name)
       self.Names.Item(name)
-    rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException
+    rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException, VBAMethodMissingError
       begin
         self.Parent.Names.Item(name)
       rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException
@@ -273,4 +276,16 @@ module RobustExcelOle
 
   end
 
+  # @private
+  class NameNotFound < NamesREOError               
+  end
+
+  # @private
+  class NameAlreadyExists < NamesREOError          
+  end
+
+  # @private
+  class RangeNotCreated < MiscREOError             
+  end  
+
 end

data/lib/robust_excel_ole/vba_objects.rb

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+
+module RobustExcelOle
+
+  class VbaObjects < Base
+
+    def to_reo
+      self
+    end
+
+    # @private
+    def address_tool
+      excel.address_tool
+    end
+
+  end
+
+  # @private
+  class RangeNotEvaluatable < MiscREOError         
+  end
+
+  # @private
+  class OptionInvalid < MiscREOError               
+  end
+
+  # @private
+  class ObjectNotAlive < MiscREOError              
+  end
+
+end

data/lib/robust_excel_ole/version.rb

@@ -1,3 +1,3 @@
 module RobustExcelOle
-  VERSION = "1.14"
+  VERSION = "1.18.1"
 end

data/lib/robust_excel_ole/workbook.rb

@@ -12,33 +12,33 @@ module RobustExcelOle
   class Workbook < RangeOwners
 
     #include General 
-
-    attr_accessor :excel
-    attr_accessor :ole_workbook
-    attr_accessor :stored_filename
-    attr_accessor :color_if_modified
-    attr_accessor :was_open
-    attr_reader :workbook
+    
+    attr_reader :ole_workbook
+    attr_reader :excel
+    attr_reader :stored_filename
 
     alias ole_object ole_workbook
 
-    DEFAULT_OPEN_OPTS = {
-      :default => {:excel => :current},
+    CORE_DEFAULT_OPEN_OPTS = {
+      :default => {:excel => :current}, 
       :force => {},
-      :update_links => :never,
+      :update_links => :never 
+    }.freeze
+
+    DEFAULT_OPEN_OPTS = {
       :if_unsaved    => :raise,
       :if_obstructed => :raise,
       :if_absent     => :raise,
-      :if_exists => :raise,
-      :check_compatibility => false
-    }.freeze
-
-    CORE_DEFAULT_OPEN_OPTS = {
-      :default => {:excel => :current}, :force => {}, :update_links => :never
-    }.freeze
+      :if_exists => :raise
+    }.merge(CORE_DEFAULT_OPEN_OPTS).freeze  
 
-    ABBREVIATIONS = [[:default,:d], [:force, :f], [:excel, :e], [:visible, :v],
-                     [:if_obstructed, :if_blocked]].freeze
+    ABBREVIATIONS = [
+      [:default,:d],
+      [:force, :f],
+      [:excel, :e],
+      [:visible, :v],
+      [:if_obstructed, :if_blocked]
+    ].freeze
 
 
     # opens a workbook.
@@ -84,50 +84,59 @@ module RobustExcelOle
     # :visible              true -> makes the workbook visible
     # :check_compatibility  true -> check compatibility when saving
     # :update_links         true -> user is being asked how to update links, false -> links are never updated
-    # @return [Workbook] a representation of a workbook
-    def self.new(file_or_workbook, opts = { }, &block)
-      options = process_options(opts)
-      if file_or_workbook.is_a? WIN32OLE
+    # @return [Workbook] a representation of a workbook   
+    def self.new(file_or_workbook, opts = { })
+      process_options(opts)
+      case file_or_workbook
+      when NilClass
+        raise FileNameNotGiven, 'filename is nil' 
+      when WIN32OLE
         file = file_or_workbook.Fullname.tr('\\','/') 
-      else
+      when Workbook
+        file = file_or_workbook.Fullname.tr('\\','/')
+      when String
         file = file_or_workbook
-        raise(FileNameNotGiven, 'filename is nil') if file.nil?
-        raise(FileNotFound, "file #{General.absolute_path(file).inspect} is a directory") if File.directory?(file)
+        raise FileNotFound, "file #{General.absolute_path(file).inspect} is a directory" if File.directory?(file)
+      else
+        raise TypeREOError, 'given object is neither a filename, a Win32ole, nor a Workbook object'
       end
       # try to fetch the workbook from the bookstore
+      set_was_open opts, file_or_workbook.is_a?(WIN32OLE)
       book = nil
-      if options[:force][:excel] != :new
+      if opts[:force][:excel] != :new
         # if readonly is true, then prefer a book that is given in force_excel if this option is set              
-        forced_excel = 
-          (options[:force][:excel].nil? || options[:force][:excel] == :current) ? 
-            (excel_class.new(:reuse => true) if !JRUBY_BUG_CONNECT) : excel_of(options[:force][:excel])              
+        forced_excel = begin
+          (opts[:force][:excel].nil? || opts[:force][:excel] == :current) ? 
+            (excel_class.new(:reuse => true) if !::CONNECT_JRUBY_BUG) : opts[:force][:excel].to_reo.excel
+        rescue NoMethodError
+          raise TypeREOError, "provided Excel option value is neither an Excel object nor a valid option"
+        end
         begin
           book = if File.exists?(file)
-            bookstore.fetch(file, :prefer_writable => !(options[:read_only]),
-                                  :prefer_excel    => (options[:read_only] ? forced_excel : nil))
+            bookstore.fetch(file, :prefer_writable => !(opts[:read_only]),
+                                  :prefer_excel    => (opts[:read_only] ? forced_excel : nil))
           end
         rescue
-          trace "#{$!.message}"
+          raise
+          #trace "#{$!.message}"
         end
         if book 
-          book.was_open = book.alive?
+          set_was_open opts, book.alive?
           # drop the fetched workbook if it shall be opened in another Excel instance
           # or the workbook is an unsaved workbook that should not be accepted
-          if (options[:force][:excel].nil? || options[:force][:excel] == :current || forced_excel == book.excel) &&
-            !(book.alive? && !book.saved && (options[:if_unsaved] != :accept))
-            options[:force][:excel] = book.excel if book.excel && book.excel.alive?
-            book.ensure_workbook(file,options)
-            book.set_options(file,options)
+          if (opts[:force][:excel].nil? || opts[:force][:excel] == :current || forced_excel == book.excel) &&
+            !(book.alive? && !book.saved && (opts[:if_unsaved] != :accept))
+            opts[:force][:excel] = book.excel if book.excel && book.excel.alive?
+            book.ensure_workbook(file,opts)
+            book.send :apply_options, file, opts
             return book
           end
         end
       end        
-      super(file_or_workbook, options, &block)
+      super(file_or_workbook, opts)
     end
 
-    def self.open(file_or_workbook, opts = { }, &block)
-      new(file_or_workbook, opts, &block)
-    end
+    singleton_class.send :alias_method, :open, :new
 
     # creates a new Workbook object, if a file name is given
     # Promotes the win32ole workbook to a Workbook object, if a win32ole-workbook is given
@@ -135,26 +144,23 @@ module RobustExcelOle
     # @param [Hash]    opts             
     # @option opts [Symbol] see above
     # @return [Workbook] a workbook
-    def initialize(file_or_workbook, options = { }, &block)
+    def initialize(file_or_workbook, opts)
       if file_or_workbook.is_a? WIN32OLE
         @ole_workbook = file_or_workbook
-        ole_excel = begin
-          WIN32OLE.connect(@ole_workbook.Fullname).Application
-        rescue
+        ole_excel = begin 
+          @ole_workbook.Application
+        rescue WIN32OLERuntimeError
           raise ExcelREOError, 'could not determine the Excel instance'
         end
         @excel = excel_class.new(ole_excel)
-        filename = file_or_workbook.Fullname.tr('\\','/') 
+        filename = @ole_workbook.Fullname.tr('\\','/') 
       else
         filename = file_or_workbook            
-        ensure_workbook(filename, options)        
+        ensure_workbook(filename, opts)        
       end      
-      set_options(filename, options)
-      bookstore.store(self)
-      @workbook = @excel.workbook = self
-      r1c1_letters = @ole_workbook.Worksheets.Item(1).Cells.Item(1,1).Address(true,true,XlR1C1).gsub(/[0-9]/,'') #('ReferenceStyle' => XlR1C1).gsub(/[0-9]/,'')
-      address_class.new(r1c1_letters)
-      if block
+      apply_options(filename, opts)
+      store_myself
+      if block_given?
         begin
           yield self
         ensure
@@ -165,52 +171,46 @@ module RobustExcelOle
  
   private    
 
-    # translates abbreviations and synonyms and merges with default options
-    def self.process_options(options, proc_opts = {:use_defaults => true})
-      translator = proc do |opts|
-        erg = {}
-        opts.each do |key,value|
-          new_key = key
-          ABBREVIATIONS.each { |long,short| new_key = long if key == short }
-          if value.is_a?(Hash)
-            erg[new_key] = {}
-            value.each do |k,v|
-              new_k = k
-              ABBREVIATIONS.each { |l,s| new_k = l if k == s }
-              erg[new_key][new_k] = v
-            end
-          else
-            erg[new_key] = value
-          end
-        end
-        erg[:default] ||= {}
-        erg[:force] ||= {}
-        force_list = [:visible, :excel]
-        erg.each { |key,value| erg[:force][key] = value if force_list.include?(key) }
-        erg[:default][:excel] = erg[:default_excel] unless erg[:default_excel].nil?
-        erg[:force][:excel] = erg[:force_excel] unless erg[:force_excel].nil?
-        erg[:default][:excel] = :current if erg[:default][:excel] == :reuse || erg[:default][:excel] == :active
-        erg[:force][:excel] = :current if erg[:force][:excel] == :reuse || erg[:force][:excel] == :active
-        erg
-      end
-      opts = translator.call(options)
-      default_open_opts = proc_opts[:use_defaults] ? DEFAULT_OPEN_OPTS : CORE_DEFAULT_OPEN_OPTS        
-      default_opts = translator.call(default_open_opts)
-      opts = default_opts.merge(opts)
-      opts[:default] = default_opts[:default].merge(opts[:default]) unless opts[:default].nil?
-      opts[:force] = default_opts[:force].merge(opts[:force]) unless opts[:force].nil?
-      opts
+    def self.set_was_open(hash, value)
+      hash[:was_open] = value if hash.has_key?(:was_open)
     end
 
-    # returns an Excel object when given Excel, Workbook or Win32ole object representing a Workbook or an Excel
-    # @private
-    def self.excel_of(object) 
-      begin
-        object = object.to_reo if object.is_a? WIN32OLE
-        object.excel
-      rescue
-        raise TypeREOError, 'given object is neither an Excel, a Workbook, nor a Win32ole'
+    def set_was_open(hash, value)
+      self.class.set_was_open(hash, value)
+    end
+
+    def self.process_options(opts, proc_opts = {:use_defaults => true})
+      translate(opts)
+      default_opts = (proc_opts[:use_defaults] ? DEFAULT_OPEN_OPTS : CORE_DEFAULT_OPEN_OPTS).dup
+      translate(default_opts)
+      opts.merge!(default_opts) { |key, v1, v2| !v2.is_a?(Hash) ? v1 : v2.merge(v1 || {}) }
+    end
+
+    def self.translate(opts)
+      erg = {}
+      opts.each do |key,value|
+        new_key = key
+        ABBREVIATIONS.each { |long,short| new_key = long if key == short }
+        if value.is_a?(Hash)
+          erg[new_key] = {}
+          value.each do |k,v|
+            new_k = k
+            ABBREVIATIONS.each { |l,s| new_k = l if k == s }
+            erg[new_key][new_k] = v
+          end
+        else
+          erg[new_key] = value
+        end
       end
+      opts.merge!(erg)
+      opts[:default] ||= {}
+      opts[:force] ||= {}
+      force_list = [:visible, :excel]
+      opts.each { |key,value| opts[:force][key] = value if force_list.include?(key) }
+      opts[:default][:excel] = opts[:default_excel] unless opts[:default_excel].nil?
+      opts[:force][:excel] = opts[:force_excel] unless opts[:force_excel].nil?
+      opts[:default][:excel] = :current if opts[:default][:excel] == :reuse || opts[:default][:excel] == :active
+      opts[:force][:excel] = :current if opts[:force][:excel] == :reuse || opts[:force][:excel] == :active
     end
 
   public
@@ -219,93 +219,91 @@ module RobustExcelOle
     # ensures an excel but not for jruby if current Excel shall be used
     def ensure_excel(options)
       return if @excel && @excel.alive?
-      excel_option = options[:force][:excel].nil? ? options[:default][:excel] : options[:force][:excel]
+      excel_option = options[:force][:excel] || options[:default][:excel] || :current
       @excel = if excel_option == :new
         excel_class.new(:reuse => false) 
-      elsif excel_option.nil? || excel_option == :current
+      elsif excel_option == :current
         excel_class.new(:reuse => true)
+      elsif excel_option.respond_to?(:to_reo)
+        excel_option.to_reo.excel
       else
-        self.class.excel_of(excel_option)
+        raise TypeREOError, "provided Excel option value is neither an Excel object nor a valid option"
       end
-      raise ExcelREOError, "excel is not alive" unless @excel && @excel.alive?
+      raise ExcelREOError, "Excel is not alive" unless @excel && @excel.alive?
     end
 
+
     # @private    
     def ensure_workbook(filename, options)  
-      unless @ole_workbook && alive?
-        filename = @stored_filename ? @stored_filename : filename 
-        manage_nonexisting_file(filename,options)
-        excel_option = options[:force][:excel].nil? ? options[:default][:excel] : options[:force][:excel]        
-        ensure_excel(options)
-        workbooks = @excel.Workbooks
-        @ole_workbook = workbooks.Item(File.basename(filename)) rescue nil if @ole_workbook.nil?
-        if @ole_workbook
-          @was_open = true
-          manage_blocking_or_unsaved_workbook(filename,options)
-        else
-          if excel_option.nil? || excel_option == :current &&  
-            (!JRUBY_BUG_CONNECT || filename[0] != '/')
-            connect(filename,options)
-          else 
-            open_or_create_workbook(filename,options)
-          end
-        end       
+      set_was_open options, true
+      return if (@ole_workbook && alive? && (options[:read_only].nil? || @ole_workbook.ReadOnly == options[:read_only]))
+      set_was_open options, false
+      if options[:if_unsaved]==:accept && 
+        ((options[:read_only]==true && self.ReadOnly==false) || (options[:read_only]==false && self.ReadOnly==true))
+        raise OptionInvalid, ":if_unsaved:accept and change of read-only mode is not possible"
       end
+      filename = @stored_filename ? @stored_filename : filename 
+      manage_nonexisting_file(filename,options)
+      excel_option = options[:force][:excel].nil? ? options[:default][:excel] : options[:force][:excel]        
+      ensure_excel(options)
+      workbooks = @excel.Workbooks
+      @ole_workbook = workbooks.Item(File.basename(filename)) rescue nil if @ole_workbook.nil?
+      if @ole_workbook && alive?
+        set_was_open options, true
+        manage_blocking_or_unsaved_workbook(filename,options)
+        open_or_create_workbook(filename,options) if @ole_workbook.ReadOnly != options[:read_only]
+      else
+        if (excel_option.nil? || excel_option == :current) &&  
+          !(::CONNECT_JRUBY_BUG && filename[0] == '/')
+          connect(filename,options)
+        else 
+          open_or_create_workbook(filename,options)
+        end
+      end       
     end
 
-    # @private
-    def set_options(filename, options)
+  private
+
+    # applies options to workbook named with filename
+    def apply_options(filename, options)
+      # changing read-only mode      
+      #ensure_workbook(filename, options) if options[:read_only] && options[:read_only] != @ole_workbook.ReadOnly
       if (!options[:read_only].nil?) && options[:read_only] != @ole_workbook.ReadOnly
-        #raise OptionInvalid, ":if_unsaved:accept and changing read-only mode is not possible" if options[:if_unsaved]==:accept
-        @excel.with_displayalerts(false) { @ole_workbook.Close }
-        @ole_workbook = nil        
-        open_or_create_workbook(filename, options)
+        ensure_workbook(filename, options) 
       end
       retain_saved do
         self.visible = options[:force][:visible].nil? ? @excel.Visible : options[:force][:visible]
         @excel.calculation = options[:calculation] unless options[:calculation].nil?
         @ole_workbook.CheckCompatibility = options[:check_compatibility] unless options[:check_compatibility].nil?
-      end
+      end      
     end
 
-
-  private
-
-    # @private
     # connects to an unknown workbook
-    def connect(filename,options)
-      excels_number = excel_class.excels_number
-      workbooks_number = if excels_number>0 
-        excel_class.current.Workbooks.Count 
-      else 0
-      end
-      abs_filename = General.absolute_path(filename)
+    def connect(filename, options)   
+      workbooks_number = excel_class.excels_number==0 ? 0 : excel_class.current.Workbooks.Count
       @ole_workbook = begin
-        WIN32OLE.connect(abs_filename)
+        WIN32OLE.connect(General.absolute_path(filename))
       rescue
         if $!.message =~ /moniker/
-          raise WorkbookConnectingBlockingError
-        else
-          raise WorkbookConnectingUnknownError
+          raise WorkbookConnectingBlockingError, "some workbook is blocking when connecting"
+        else 
+          raise WorkbookConnectingUnknownError, "unknown error when connecting to a workbook"
         end
       end
       ole_excel = begin
         @ole_workbook.Application     
       rescue 
         if $!.message =~ /dispid/
-          raise WorkbookConnectingUnsavedError
-        else
-          raise WorkbookConnectingUnknownError
+          raise WorkbookConnectingUnsavedError, "workbook is unsaved when connecting"
+        else 
+          raise WorkbookConnectingUnknownError, "unknown error when connecting to a workbook"
         end
       end
+      set_was_open options, (ole_excel.Workbooks.Count == workbooks_number)
       @excel = excel_class.new(ole_excel)
-      excels_number_after = excel_class.excels_number
-      workbooks_number_after = ole_excel.Workbooks.Count
-      @was_open = (excels_number_after==excels_number) && (workbooks_number_after==workbooks_number)      
     end
 
-    # @private
-    def manage_nonexisting_file(filename,options)   
+    def manage_nonexisting_file(filename, options)   
       return if File.exist?(filename)
       abs_filename = General.absolute_path(filename)
       if options[:if_absent] == :create
@@ -323,11 +321,12 @@ module RobustExcelOle
       end
     end
 
-    # @private
-    def manage_blocking_or_unsaved_workbook(filename,options)
-      obstructed_by_other_book = if (File.basename(filename) == File.basename(@ole_workbook.Fullname)) 
-        General.absolute_path(filename) != @ole_workbook.Fullname
-      end      
+    def manage_blocking_or_unsaved_workbook(filename, options)
+      filename = General.absolute_path(filename)
+      filename = General.canonize(filename)
+      previous_file = General.canonize(@ole_workbook.Fullname)
+      obstructed_by_other_book = (File.basename(filename) == File.basename(previous_file)) &&
+                                 (File.dirname(filename) != File.dirname(previous_file)) 
       if obstructed_by_other_book
         # workbook is being obstructed by a workbook with same name and different path
         manage_blocking_workbook(filename,options)        
@@ -339,8 +338,7 @@ module RobustExcelOle
       end        
     end
 
-    # @private
-    def manage_blocking_workbook(filename,options)
+    def manage_blocking_workbook(filename, options)
       case options[:if_obstructed]
       when :raise
         raise WorkbookBlocked, "can't open workbook #{filename},
@@ -354,7 +352,8 @@ module RobustExcelOle
         manage_saving_workbook(filename, options)        
       when :close_if_saved
         if !@ole_workbook.Saved
-          raise WorkbookBlocked, "workbook with the same name in a different path is unsaved: #{@ole_workbook.Fullname.tr('\\','/')}"
+          raise WorkbookBlocked, "workbook with the same name in a different path is unsaved: #{@ole_workbook.Fullname.tr('\\','/')}" +
+          "\nHint: Use the option :if_blocked => :save to save the workbook"
         else
           manage_forgetting_workbook(filename, options)
         end
@@ -366,15 +365,14 @@ module RobustExcelOle
       end
     end
 
-    # @private
-    def manage_unsaved_workbook(filename,options)
+    def manage_unsaved_workbook(filename, options)
       case options[:if_unsaved]
       when :raise
         raise WorkbookNotSaved, "workbook is already open but not saved: #{File.basename(filename).inspect}" +
         "\nHint: Save the workbook or open the workbook using option :if_unsaved with values :forget and :accept to
          close the unsaved workbook and reopen it, or to let the unsaved workbook open, respectively"
       when :forget
-        manage_forgetting_workbook(filename,options)
+        manage_forgetting_workbook(filename, options)
       when :accept
         # do nothing
       when :save
@@ -389,29 +387,26 @@ module RobustExcelOle
       end
     end
 
-    # @private
     def manage_forgetting_workbook(filename, options)
       @excel.with_displayalerts(false) { @ole_workbook.Close }
       @ole_workbook = nil
       open_or_create_workbook(filename, options)
     end
 
-    # @private
     def manage_saving_workbook(filename, options)
       save unless @ole_workbook.Saved
       manage_forgetting_workbook(filename, options)
     end
 
-    # @private
     def manage_new_excel(filename, options)
       @excel = excel_class.new(:reuse => false)
       @ole_workbook = nil
       open_or_create_workbook(filename, options)
     end
     
-    # @private
-    def open_or_create_workbook(filename, options)       
-      return if @ole_workbook && options[:if_unsaved] != :alert && options[:if_unsaved] != :excel
+    def open_or_create_workbook(filename, options)
+      return if @ole_workbook && options[:if_unsaved] != :alert && options[:if_unsaved] != :excel &&
+        (options[:read_only].nil? || options[:read_only]==@ole_workbook.ReadOnly )
       begin
         abs_filename = General.absolute_path(filename)
         begin
@@ -426,7 +421,7 @@ module RobustExcelOle
                                       updatelinks_vba(options[:update_links]), 
                                       options[:read_only] )
           end
-        rescue WIN32OLERuntimeError => msg
+        rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
           # for Excel2007: for option :if_unsaved => :alert and user cancels: this error appears?
           # if yes: distinguish these events
           raise UnexpectedREOError, "cannot open workbook: #{msg.message} #{msg.backtrace}"
@@ -435,29 +430,27 @@ module RobustExcelOle
           # workaround for bug in Excel 2010: workbook.Open does not always return the workbook when given file name
           begin
             @ole_workbook = workbooks.Item(File.basename(filename))
-          rescue WIN32OLERuntimeError => msg
+          rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
             raise UnexpectedREOError, "WIN32OLERuntimeError: #{msg.message}"
           end
-        rescue WIN32OLERuntimeError => msg
+        rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
           raise UnexpectedREOError, "WIN32OLERuntimeError: #{msg.message} #{msg.backtrace}"
         end
       end
     end    
            
-    # @private
     # translating the option UpdateLinks from REO to VBA
     # setting UpdateLinks works only if calculation mode is automatic,
     # parameter 'UpdateLinks' has no effect
     def updatelinks_vba(updatelinks_reo)
       case updatelinks_reo
-      when :alert then RobustExcelOle::XlUpdateLinksUserSetting
-      when :never then RobustExcelOle::XlUpdateLinksNever
+      when :alert  then RobustExcelOle::XlUpdateLinksUserSetting
+      when :never  then RobustExcelOle::XlUpdateLinksNever
       when :always then RobustExcelOle::XlUpdateLinksAlways
-      else RobustExcelOle::XlUpdateLinksNever
+      else              RobustExcelOle::XlUpdateLinksNever
       end
     end
 
-    # @private
     # workaround for linked workbooks for Excel 2007:
     # opening and closing a dummy workbook if Excel has no workbooks.
     # delay: with visible: 0.2 sec, without visible almost none
@@ -467,7 +460,7 @@ module RobustExcelOle
       workaround_condition = @excel.Version.split('.').first.to_i == 12 && workbooks.Count == 0
       if workaround_condition
         workbooks.Add
-        @excel.calculation = options[:calculation].nil? ? @excel.calculation : options[:calculation]
+        @excel.calculation = options[:calculation].nil? ? @excel.properties[:calculation] : options[:calculation]
       end
       begin
         # @excel.with_displayalerts(update_links_opt == :alert ? true : @excel.displayalerts) do
@@ -521,13 +514,10 @@ module RobustExcelOle
       else
         close_workbook
       end
-      # trace "close: canceled by user" if alive? &&
-      #  (opts[:if_unsaved] == :alert || opts[:if_unsaved] == :excel) && (not @ole_workbook.Saved)
     end
 
   private
 
-    # @private
     def close_workbook
       @ole_workbook.Close if alive?
       @ole_workbook = nil unless alive?
@@ -545,20 +535,20 @@ module RobustExcelOle
       end
     end
 
-    def self.for_reading(*args, &block)
-      args = args.dup
-      opts = args.last.is_a?(Hash) ? args.pop : {}
-      opts = {:writable => false}.merge(opts)
-      args.push opts
-      unobtrusively(*args, &block)
+    def for_reading(opts = { }, &block)
+      unobtrusively({:writable => false}.merge(opts), &block)
     end
 
-    def self.for_modifying(*args, &block)
-      args = args.dup
-      opts = args.last.is_a?(Hash) ? args.pop : {}
-      opts = {:writable => true}.merge(opts)
-      args.push opts
-      unobtrusively(*args, &block)
+    def for_modifying(opts = { }, &block)
+      unobtrusively({:writable => true}.merge(opts), &block)
+    end
+
+    def self.for_reading(arg, opts = { }, &block)
+      unobtrusively(arg, {:writable => false}.merge(opts), &block)
+    end
+
+    def self.for_modifying(arg, opts = { }, &block)
+      unobtrusively(arg, {:writable => true}.merge(opts), &block)
     end
 
     # allows to read or modify a workbook such that its state remains unchanged
@@ -570,97 +560,64 @@ module RobustExcelOle
     # @option opts [Boolean] :writable  true (default)/false changes of the workbook shall be saved/not saved
     # @option opts [Boolean] :keep_open whether the workbook shall be kept open after unobtrusively opening (default: false)
     # @return [Workbook] a workbook
-    def self.unobtrusively(file_or_workbook, opts = { })
-      opts = process_options(opts, :use_defaults => false)
-      raise OptionInvalid, 'contradicting options' if opts[:writable] && opts[:read_only]       
-      opts = opts.merge({:force => {:excel => opts[:if_closed]}, :if_closed => :current, 
-                         :if_unsaved => :accept, :keep_open => false})
-      opts = opts.merge({:read_only => opts[:read_only]}) unless opts[:read_only].nil?
+    def self.unobtrusively(file_or_workbook, opts = { }, &block)
       file = (file_or_workbook.is_a? WIN32OLE) ? file_or_workbook.Fullname.tr('\\','/') : file_or_workbook
+      unobtrusively_opening(file, opts, nil, &block)
+    end
+
+    def unobtrusively(opts = { }, &block)
+      file = @stored_filename
+      self.class.unobtrusively_opening(file, opts, alive?, &block)
+    end
+
+  private
+
+    def self.unobtrusively_opening(file, opts, book_is_alive, &block)
+      process_options(opts)
+      opts = {:if_closed => :current, :keep_open => false}.merge(opts)    
+      raise OptionInvalid, 'contradicting options' if opts[:writable] && opts[:read_only] 
+      if book_is_alive.nil?
+        prefer_writable = ((!(opts[:read_only]) || opts[:writable] == true) &&
+                           !(opts[:read_only].nil? && opts[:writable] == false))
+        known_book = bookstore.fetch(file, :prefer_writable => prefer_writable) 
+      end
+      excel_opts = if (book_is_alive==false || (book_is_alive.nil? && (known_book.nil? || !known_book.alive?)))
+        {:force => {:excel => opts[:if_closed]}}
+      else
+        {:force => {:excel => opts[:force][:excel]}, :default => {:excel => opts[:default][:excel]}}
+      end
+      open_opts = excel_opts.merge({:if_unsaved => :accept})
       begin
-        book = open(file)
+        open_opts[:was_open] = nil
+        book = open(file, open_opts)
         was_visible = book.visible
         was_writable = book.writable
         was_saved = book.saved
         was_check_compatibility = book.check_compatibility
-        was_calculation = book.excel.calculation
-        book.set_options(file,opts)
-        if !was_saved && ((opts[:writable] && !was_writable) || (opts[:read_only] && was_writable))
-          raise NotImplementedREOError, 'unsaved read-only workbook shall be written'
-        end
+        was_calculation = book.excel.properties[:calculation]
+        book.send :apply_options, file, opts
         yield book
       ensure
         if book && book.alive?
-          do_not_write = (opts[:read_only] || (opts[:read_only].nil? && opts[:writable] == false))
-          book.save unless was_saved || do_not_write || book.ReadOnly
-          # open and close if the read_only mode has changed
+          do_not_write = opts[:read_only] || opts[:writable]==false
+          book.save unless book.saved || do_not_write || !book.writable
           if (opts[:read_only] && was_writable) || (!opts[:read_only] && !was_writable)
-            book = open(file, :read_only => !was_writable, :if_unsaved => :forget)
+            book.send :apply_options, file, opts.merge({:read_only => !was_writable, 
+                                            :if_unsaved => (opts[:writable]==false ? :forget : :save)})
           end
-          if book.was_open
+          was_open = open_opts[:was_open]
+          if was_open
             book.visible = was_visible    
             book.CheckCompatibility = was_check_compatibility
             book.excel.calculation = was_calculation
           end
-          book.Saved = (was_saved || !book.was_open)
-          book.close unless book.was_open || opts[:keep_open]
-        end
-      end
-    end
-
-    # allows to read or modify a workbook such that its state remains unchanged
-    # state comprises: open, saved, writable, visible, calculation mode, check compatibility
-    # @param [String] file_or_workbook     a file name or WIN32OLE workbook
-    # @param [Hash]   opts        the options
-    # @option opts [Variant] :if_closed  :current (default), :new or an Excel instance
-    # @option opts [Boolean] :read_only true/false (default), open the workbook in read-only/read-write modus (save changes)
-    # @option opts [Boolean] :writable  true (default)/false changes of the workbook shall be saved/not saved
-    # @option opts [Boolean] :keep_open whether the workbook shall be kept open after unobtrusively opening (default: false)
-    # @return [Workbook] a workbook
-=begin
-    def self.unobtrusively(file_or_workbook, opts = { })
-      book = new(file_or_workbook)
-      book.unobtrusively(opts)
-    end
-=end
-
-    def unobtrusively(opts = { })
-      opts = process_options(opts, :use_defaults => false)
-      raise OptionInvalid, 'contradicting options' if opts[:writable] && opts[:read_only]       
-      opts = opts.merge({:force => {:excel => opts[:if_closed]}, :if_closed => :current, 
-                         :if_unsaved => :accept, :keep_open => false})
-      opts = opts.merge({:read_only => opts[:read_only]}) unless opts[:read_only].nil?
-      file = stored_filename
-      begin
-        book = open(file, opts)
-        was_visible = book.visible
-        was_saved = book.saved
-        was_writable = book.was_writable
-        was_check_compatibility = book.CheckCompatibility
-        was_calculation = book.excel.calculation
-        if !was_saved && ((opts[:writable] && !was_writable) || (opts[:read_only] && was_writable))
-          raise NotImplementedREOError, 'unsaved read-only workbook shall be written'
-        end        
-        yield book
-      ensure
-        if book && book.alive?
-          do_not_write = (opts[:read_only] || (opts[:read_only].nil? && opts[:writable] == false))
-          book.save unless book.saved || do_not_write || book.ReadOnly
-          # open and close if the read_only mode has changed
-          if (opts[:read_only] && was_writable) || (!opts[:read_only] && !was_writable)           
-            book = open(file, :read_only => !was_writable, :if_unsaved => :forget)
-          end
-          if book.was_open
-            book.visible = was_visible             
-            book.CheckCompatibility = was_check_compatibility            
-            book.excel.calculation = was_calculation
-          end
-          book.Saved = (was_saved || !book.was_open)
-          book.close unless book.was_open || opts[:keep_open]
+          book.Saved = (was_saved || !was_open)
+          book.close unless was_open || opts[:keep_open]
         end
       end
     end
 
+  public 
 
     # reopens a closed workbook
     # @options options
@@ -675,10 +632,6 @@ module RobustExcelOle
     def save(opts = { })  # option opts is deprecated #
       raise ObjectNotAlive, 'workbook is not alive' unless alive?
       raise WorkbookReadOnly, 'Not opened for writing (opened with :read_only option)' if @ole_workbook.ReadOnly   
-      # if you have open the workbook with :read_only => true,
-      # then you could close the workbook and open it again with option :read_only => false
-      # otherwise the workbook may already be open writable in an another Excel instance
-      # then you could use this workbook or close the workbook there
       begin
         @ole_workbook.Save
       rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
@@ -708,12 +661,12 @@ module RobustExcelOle
     #                  :close_if_saved      -> closes the blocking workbook, if it is saved,
     #                                          otherwise raises an exception   
     # @return [Workbook], the book itself, if successfully saved, raises an exception otherwise
-    def save_as(file, opts = { })
+    def save_as(file, options = { })
       raise FileNameNotGiven, 'filename is nil' if file.nil?
       raise ObjectNotAlive, 'workbook is not alive' unless alive?
       raise WorkbookReadOnly, 'Not opened for writing (opened with :read_only option)' if @ole_workbook.ReadOnly
       raise(FileNotFound, "file #{General.absolute_path(file).inspect} is a directory") if File.directory?(file)
-      options = self.class.process_options(opts)      
+      self.class.process_options(options)      
       if File.exist?(file)
         case options[:if_exists]
         when :overwrite
@@ -768,7 +721,6 @@ module RobustExcelOle
 
   private
 
-    # @private
     def save_as_workbook(file, options)  
       dirname, basename = File.split(file)
       file_format =
@@ -778,7 +730,7 @@ module RobustExcelOle
         when '.xlsm' then RobustExcelOle::XlOpenXMLWorkbookMacroEnabled
         end
       @ole_workbook.SaveAs(General.absolute_path(file), file_format)
-      bookstore.store(self)
+      store_myself
     rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
       if msg.message =~ /SaveAs/ && msg.message =~ /Workbook/
         # trace "save: canceled by user" if options[:if_exists] == :alert || options[:if_exists] == :excel
@@ -788,6 +740,11 @@ module RobustExcelOle
       end
     end
 
+    def store_myself
+      bookstore.store(self)
+      @stored_filename = filename
+    end
+
   public
 
     # closes a given file if it is open
@@ -826,12 +783,22 @@ module RobustExcelOle
       raise NameNotFound, "could not return a sheet with name #{name.inspect}"
     end
 
+    def worksheets_count
+      @ole_workbook.Worksheets.Count
+    end
+
     def each
       @ole_workbook.Worksheets.each do |sheet|
         yield worksheet_class.new(sheet)
       end
     end
 
+    def worksheets
+      result = []
+      each { |worksheet| result << worksheet }   
+      result
+    end
+
     def each_with_index(offset = 0)
       i = offset
       @ole_workbook.Worksheets.each do |sheet|
@@ -856,36 +823,18 @@ module RobustExcelOle
       new_sheet_name = opts.delete(:as)
       last_sheet_local = last_sheet
       after_or_before, base_sheet = opts.to_a.first || [:after, last_sheet_local]
+      base_sheet_ole = base_sheet.ole_worksheet
       begin
-        if !JRUBY_BUG_COPYSHEETS
-          if sheet
-            sheet.Copy({ after_or_before.to_s => base_sheet.ole_worksheet })
-          else
-            @ole_workbook.Worksheets.Add({ after_or_before.to_s => base_sheet.ole_worksheet })
-            #@ole_workbook.Worksheets.Item(ole_workbook.Worksheets.Count).Activate
-          end
+        if !::COPYSHEETS_JRUBY_BUG          
+          add_or_copy_sheet_simple(sheet, { after_or_before.to_s => base_sheet_ole })
         else
           if after_or_before == :before 
-            if sheet
-              sheet.Copy(base_sheet.ole_worksheet)
-            else
-              ole_workbook.Worksheets.Add(base_sheet.ole_worksheet)
-            end
+            add_or_copy_sheet_simple(sheet, base_sheet_ole)
           else
-            #not_given = WIN32OLE_VARIANT.new(nil, WIN32OLE::VARIANT::VT_NULL)
-            #ole_workbook.Worksheets.Add(not_given,base_sheet.ole_worksheet)          
             if base_sheet.name != last_sheet_local.name
-              if sheet
-                sheet.Copy(base_sheet.Next)
-              else
-                ole_workbook.Worksheets.Add(base_sheet.Next)
-              end
+              add_or_copy_sheet_simple(sheet, base_sheet.Next)
             else
-              if sheet
-                sheet.Copy(base_sheet.ole_worksheet)  
-              else
-                ole_workbook.Worksheets.Add(base_sheet.ole_worksheet) 
-              end
+              add_or_copy_sheet_simple(sheet, base_sheet_ole)
               base_sheet.Move(ole_workbook.Worksheets.Item(ole_workbook.Worksheets.Count-1))
               ole_workbook.Worksheets.Item(ole_workbook.Worksheets.Count).Activate
             end
@@ -894,14 +843,23 @@ module RobustExcelOle
       rescue WIN32OLERuntimeError, NameNotFound, Java::OrgRacobCom::ComFailException
         raise WorksheetREOError, "could not add given worksheet #{sheet.inspect}"
       end
-      #ole_sheet = @excel.Activesheet
-      ole_sheet = ole_workbook.Activesheet
-      #ole_sheet = ole_sheet.nil? ? ole_workbook.Worksheets.Item(ole_workbook.Worksheets.Count) : ole_sheet
-      new_sheet = worksheet_class.new(ole_sheet)
+      new_sheet = worksheet_class.new(ole_workbook.Activesheet)
       new_sheet.name = new_sheet_name if new_sheet_name
       new_sheet
     end
 
+  private
+  
+    def add_or_copy_sheet_simple(sheet, base_sheet_ole_or_hash)
+      if sheet
+        sheet.Copy(base_sheet_ole_or_hash)  
+      else
+        ole_workbook.Worksheets.Add(base_sheet_ole_or_hash) 
+      end
+    end 
+
+  public
+
     # for compatibility to older versions
     def add_sheet(sheet = nil, opts = { })
       add_or_copy_sheet(sheet, opts)
@@ -931,30 +889,15 @@ module RobustExcelOle
     # @param [String]  name  the name of the range
     # @param [Variant] value the contents of the range
     def []= (name, value)
-      old_color_if_modified = @color_if_modified
-      workbook.color_if_modified = 42  # 42 - aqua-marin, 4-green
-      set_namevalue_glob(name,value)   
-      workbook.color_if_modified = old_color_if_modified
+      set_namevalue_glob(name, value, :color => 42)   
     end
 
     # sets options
     # @param [Hash] opts
     def for_this_workbook(opts)
       return unless alive?
-      opts = self.class.process_options(opts, :use_defaults => false)
-      visible_before = visible
-      check_compatibility_before = check_compatibility
-      unless opts[:read_only].nil?
-        # if the ReadOnly status shall be changed, then close and reopen it
-        if (!writable && !(opts[:read_only])) || (writable && opts[:read_only])
-          opts[:check_compatibility] = check_compatibility if opts[:check_compatibility].nil?
-          close(:if_unsaved => true)
-          open_or_create_workbook(@stored_filename, opts)
-        end
-      end
-      self.visible = opts[:force][:visible].nil? ? visible_before : opts[:force][:visible]
-      self.CheckCompatibility = opts[:check_compatibility].nil? ? check_compatibility_before : opts[:check_compatibility]
-      @excel.calculation = opts[:calculation] unless opts[:calculation].nil?
+      self.class.process_options(opts, :use_defaults => false)
+      self.send :apply_options, @stored_filename, opts
     end
 
     # brings workbook to foreground, makes it available for heyboard inputs, makes the Excel instance visible
@@ -970,7 +913,6 @@ module RobustExcelOle
       true
     rescue
       @ole_workbook = nil  # dead object won't be alive again
-      # t $!.message
       false
     end
 
@@ -990,7 +932,7 @@ module RobustExcelOle
     end
 
     def calculation
-      @excel.calculation if @ole_workbook
+      @excel.properties[:calculation] if @ole_workbook
     end
 
     # @private
@@ -1000,7 +942,7 @@ module RobustExcelOle
 
     # returns true, if the workbook is visible, false otherwise
     def visible
-      @excel.visible && @ole_workbook.Windows(@ole_workbook.Name).Visible
+      @excel.Visible && @ole_workbook.Windows(@ole_workbook.Name).Visible
     end
 
     # makes both the Excel instance and the window of the workbook visible, or the window invisible
@@ -1032,6 +974,7 @@ module RobustExcelOle
         self.filename == other_book.filename
     end
 
+    # @private
     def self.books
       bookstore.books
     end
@@ -1046,6 +989,11 @@ module RobustExcelOle
       self.class.bookstore
     end
 
+    # @private
+    def workbook
+      self
+    end
+
     # @private
     def to_s    
       self.filename.to_s
@@ -1077,16 +1025,6 @@ module RobustExcelOle
       end
     end
 
-    # @private
-    def self.address_class    
-      @address_class ||= begin
-        module_name = self.parent_name
-        "#{module_name}::Address".constantize
-      rescue NameError => e
-        Address
-      end
-    end
-
     # @private
     def excel_class        
       self.class.excel_class
@@ -1097,11 +1035,6 @@ module RobustExcelOle
       self.class.worksheet_class
     end
 
-    # @private
-    def address_class        
-      self.class.address_class
-    end
-
     include MethodHelpers
 
   private
@@ -1109,7 +1042,7 @@ module RobustExcelOle
     def method_missing(name, *args) 
       if name.to_s[0,1] =~ /[A-Z]/
         raise ObjectNotAlive, 'method missing: workbook not alive' unless alive?
-        if JRUBY_BUG_ERRORMESSAGE 
+        if ::ERRORMESSAGE_JRUBY_BUG 
           begin
             @ole_workbook.send(name, *args)
           rescue Java::OrgRacobCom::ComFailException 
@@ -1131,6 +1064,47 @@ module RobustExcelOle
 
 public
 
+  # @private
+  class WorkbookBlocked < WorkbookREOError         
+  end
+
+  # @private
+  class WorkbookNotSaved < WorkbookREOError        
+  end
+
+  # @private
+  class WorkbookReadOnly < WorkbookREOError        
+  end
+
+  # @private
+  class WorkbookBeingUsed < WorkbookREOError       
+  end
+
+  # @private
+  class WorkbookConnectingUnsavedError < WorkbookREOError        
+  end
+
+  # @private
+  class WorkbookConnectingBlockingError < WorkbookREOError       
+  end
+
+  # @private
+  class WorkbookConnectingUnknownError < WorkbookREOError       
+  end
+
+  # @private
+  class FileAlreadyExists < FileREOError           
+  end
+
+  # @private
+  class FileNameNotGiven < FileREOError            
+  end
+
+  # @private
+  class FileNotFound < FileREOError                
+  end
+  
+  
   Book = Workbook
 
 end