robust_excel_ole 1.26 → 1.31

data/lib/robust_excel_ole/list_object.rb

@@ -2,9 +2,9 @@
 
 module RobustExcelOle
 
-  class ListRow
-  end
-
+  using ToReoRefinement
+  using FindAllIndicesRefinement
+ 
   # This class essentially wraps a Win32Ole ListObject. 
   # You can apply all VBA methods (starting with a capital letter) 
   # that you would apply for a ListObject. 
@@ -59,121 +59,25 @@ module RobustExcelOle
         end
       end
 
-
       ole_table = @ole_table
+
       @row_class = Class.new(ListRow) do
 
         @@ole_table = ole_table
 
-        def initialize(row_number)
-          @ole_listrow = @@ole_table.ListRows.Item(row_number)
-        end
-
-        # returns the value of the cell with given column name or number
-        # @param [Variant]  column number or column name
-        # @return [Variant] value of the cell 
-        def [] column_number_or_name
-          begin
-            ole_cell = @@ole_table.Application.Intersect(
-              @ole_listrow.Range, @@ole_table.ListColumns.Item(column_number_or_name).Range)
-            ole_cell.Value
-          rescue WIN32OLERuntimeError
-            raise TableRowError, "could not determine the value at column #{column_number_or_name}"
-          end
+        def ole_table
+          @@ole_table
         end
+      
+      end      
 
+    end
 
-        def []=(column_number_or_name, value)
-          begin
-            ole_cell = @@ole_table.Application.Intersect(
-              @ole_listrow.Range, @@ole_table.ListColumns.Item(column_number_or_name).Range)
-            ole_cell.Value = value
-          rescue WIN32OLERuntimeError
-            raise TableRowError, "could not assign value #{value.inspect} to cell at column #{column_number_or_name}"
-          end
-        end
-
-        # values of the row
-        # @return [Array] values of the row
-        def values
-          begin
-            @ole_listrow.Range.Value.first
-          rescue WIN32OLERuntimeError
-            raise TableError, "could not read values"
-          end
-        end
-
-        # sets the values of the row
-        # @param [Array] values of the row
-        def set_values values
-          begin
-            updated_values = self.values
-            updated_values[0,values.length] = values
-            @ole_listrow.Range.Value = [updated_values]
-            values
-          rescue WIN32OLERuntimeError
-            raise TableError, "could not set values #{values.inspect}"
-          end
-        end
-
-        # deletes the values of the row
-        def delete_values
-          begin
-            @ole_listrow.Range.Value = [[].fill(nil,0..(@@ole_table.ListColumns.Count)-1)]
-            nil
-          rescue WIN32OLERuntimeError
-            raise TableError, "could not delete values"
-          end
-        end
-
-        def method_missing(name, *args)
-          name_str = name.to_s
-          core_name = name_str[-1]!='=' ? name_str : name_str[0..-2]
-          column_names = @@ole_table.HeaderRowRange.Value.first
-          column_name = column_names.find do |c|
-            c == core_name ||  
-            c.gsub(/\W/,'') == core_name ||
-            c.replace_umlauts == core_name ||
-            c.gsub(/\W/,'').replace_umlauts == core_name ||
-            c.gsub(/\W/,'').replace_umlauts.underscore.gsub(/[^[\w\d]]/, '_').delete_multiple_underscores == core_name           
-          end
-          if column_name
-            method_name = core_name.gsub(/\W/,'') + (name_str[-1]!='=' ? "" : "=")
-            define_and_call_method(column_name,method_name,*args)
-          else
-            super(name, *args)
-          end
-        end
-
-      private
-
-        def define_and_call_method(column_name,method_name,*args)
-          ole_cell = @@ole_table.Application.Intersect(
-              @ole_listrow.Range, @@ole_table.ListColumns.Item(column_name).Range)
-          define_getting_setting_method(ole_cell,method_name)            
-          self.send(method_name, *args)
-        end
-       
-        def define_getting_setting_method(ole_cell,name)
-          if name[-1] != '='
-            self.class.define_method(name) do
-              ole_cell.Value
-            end
-          else
-            self.class.define_method(name) do |value|
-              ole_cell.Value = value
-            end
-          end
-        end
-      end
-
-      # accesses a table row object
-      # @param [Integer]  a row number (>= 1)
-      # @return [ListRow] a object of dynamically constructed class with superclass ListRow 
-      def [] row_number
-        @row_class.new(row_number)
-      end
-
+    # accesses a table row object
+    # @param [Integer]  a row number (>= 1)
+    # @return [ListRow] a object of dynamically constructed class with superclass ListRow 
+    def [] row_number
+      @row_class.new(row_number)
     end
 
     # @return [Array] a list of column names
@@ -213,7 +117,7 @@ module RobustExcelOle
 
     # deletes a row
     # @param [Integer] position of the old row
-    def delete_row(row_number)
+    def delete_row(row_number)                          # :nodoc: #
       begin
         @ole_table.ListRows.Item(row_number).Delete
       rescue WIN32OLERuntimeError
@@ -223,7 +127,7 @@ module RobustExcelOle
 
     # deletes a column
     # @param [Variant] column number or column name
-    def delete_column(column_number_or_name)
+    def delete_column(column_number_or_name)              # :nodoc: #
       begin
         @ole_table.ListColumns.Item(column_number_or_name).Delete
       rescue WIN32OLERuntimeError
@@ -257,7 +161,7 @@ module RobustExcelOle
     # renames a row
     # @param [String] previous name or number of the column
     # @param [String] new name of the column   
-    def rename_column(name_or_number, new_name)
+    def rename_column(name_or_number, new_name)              # :nodoc: #
       begin
         @ole_table.ListColumns.Item(name_or_number).Name = new_name
       rescue
@@ -351,7 +255,7 @@ module RobustExcelOle
       listrows = @ole_table.ListRows      
       result = []
       (1..listrows.Count).each do |row_number|
-        row_values(row_number).find_each_index(value).each do |col_number|
+        row_values(row_number).find_all_indices(value).each do |col_number|
           result << @ole_table.Application.Intersect(listrows.Item(row_number).Range, 
                                                      @ole_table.ListColumns.Item(col_number+1).Range).to_reo
         end
@@ -426,6 +330,5 @@ module RobustExcelOle
   end
 
   Table = ListObject
-  TableRow = ListRow
 
 end

data/lib/robust_excel_ole/list_row.rb

@@ -0,0 +1,128 @@
+# -*- coding: utf-8 -*-
+
+module RobustExcelOle
+
+  using StringRefinement
+
+  class ListRow    
+
+    def initialize(row_number)
+      @ole_listrow = ole_table.ListRows.Item(row_number)
+    end
+
+    # returns the value of the cell with given column name or number
+    # @param [Variant]  column number or column name
+    # @return [Variant] value of the cell 
+    def [] column_number_or_name
+      begin
+        ole_cell = ole_table.Application.Intersect(
+          @ole_listrow.Range, ole_table.ListColumns.Item(column_number_or_name).Range)
+        ole_cell.Value
+      rescue WIN32OLERuntimeError
+        raise TableRowError, "could not determine the value at column #{column_number_or_name}"
+      end
+    end
+
+    # sets the value of the cell with given column name or number
+    # @param [Variant] column number or column name
+    # @param [Variant] value of the cell
+    def []=(column_number_or_name, value)
+      begin
+        ole_cell = ole_table.Application.Intersect(
+          @ole_listrow.Range, ole_table.ListColumns.Item(column_number_or_name).Range)
+        ole_cell.Value = value
+      rescue WIN32OLERuntimeError
+        raise TableRowError, "could not assign value #{value.inspect} to cell at column #{column_number_or_name}"
+      end
+    end
+
+    # values of the row
+    # @return [Array] values of the row
+    def values
+      begin
+        @ole_listrow.Range.Value.first
+      rescue WIN32OLERuntimeError
+        raise TableError, "could not read values"
+      end
+    end
+
+    # sets the values of the row
+    # @param [Array] values of the row
+    def set_values values
+      begin
+        updated_values = self.values
+        updated_values[0,values.length] = values
+        @ole_listrow.Range.Value = [updated_values]
+        values
+      rescue WIN32OLERuntimeError
+        raise TableError, "could not set values #{values.inspect}"
+      end
+    end
+
+    # deletes the values of the row
+    def delete_values
+      begin
+        @ole_listrow.Range.Value = [[].fill(nil,0..(ole_table.ListColumns.Count)-1)]
+        nil
+      rescue WIN32OLERuntimeError
+        raise TableError, "could not delete values"
+      end
+    end        
+
+    def method_missing(name, *args)
+      name_str = name.to_s
+      core_name = name_str[-1]!='=' ? name_str : name_str[0..-2]
+      column_names = ole_table.HeaderRowRange.Value.first
+      column_name = column_names.find do |c|
+        c == core_name ||
+        c.gsub(/\W/,'_') == core_name ||
+        c.underscore == core_name ||
+        c.underscore.gsub(/\W/,'_') == core_name ||
+        c.replace_umlauts.gsub(/\W/,'_') == core_name ||
+        c.replace_umlauts.underscore.gsub(/\W/,'_') == core_name 
+      end         
+      if column_name
+        appended_eq = (name_str[-1]!='=' ? "" : "=")
+        method_name = core_name.replace_umlauts.underscore + appended_eq 
+        define_and_call_method(column_name,method_name,*args)
+      else
+        super(name, *args)
+      end
+    end
+
+    # @private
+    def to_s    
+      inspect  
+    end
+
+    # @private
+    def inspect    
+      "#<ListRow: " + "index:#{@ole_listrow.Index}" + " size:#{ole_table.ListColumns.Count}" + " #{ole_table.Name}" + ">"
+    end
+
+  private
+
+    def define_and_call_method(column_name,method_name,*args)
+      ole_cell = ole_table.Application.Intersect(
+          @ole_listrow.Range, ole_table.ListColumns.Item(column_name).Range)
+      define_getting_setting_method(ole_cell,method_name)            
+      self.send(method_name, *args)
+    end
+   
+    def define_getting_setting_method(ole_cell,name)
+      if name[-1] != '='
+        self.class.define_method(name) do
+          ole_cell.Value
+        end
+      else
+        self.class.define_method(name) do |value|
+          ole_cell.Value = value
+        end
+      end
+    end
+
+  end
+  
+  TableRow = ListRow
+
+end

data/lib/robust_excel_ole/range.rb

@@ -16,6 +16,7 @@ module RobustExcelOle
 
     alias ole_object ole_range
 
+    using ToReoRefinement
 
     def initialize(win32_range, worksheet = nil)
       @ole_range = win32_range
@@ -221,11 +222,14 @@ module RobustExcelOle
       to_s
     end
 
+    using ParentRefinement
+    using StringRefinement
+
     # @private
     def self.worksheet_class   
       @worksheet_class ||= begin
         module_name = parent_name
-        "#{module_name}::Worksheet".constantize
+        "#{module_name}::Worksheet".constantize        
       rescue NameError => e
         Worksheet
       end

data/lib/robust_excel_ole/range_owners.rb

@@ -14,7 +14,7 @@ module RobustExcelOle
     # @param  [Hash]        opts      the options
     # @option opts [Symbol] :default  the default value that is provided if no contents could be returned
     # @return [Variant] the contents of a range with given name
-    def namevalue_glob(name, opts = { :default => :__not_provided })
+    def namevalue_global(name, opts = { :default => :__not_provided })
       name_obj = begin
         name_object(name)
       rescue NameNotFound => msg
@@ -63,7 +63,7 @@ module RobustExcelOle
     # @param [String]  name  the name of a range
     # @param [Variant] value the contents of the range
     # @option opts [Symbol] :color the color of the range when set
-    def set_namevalue_glob(name, value, opts = { }) 
+    def set_namevalue_global(name, value, opts = { }) 
       begin
         name_obj = begin
           name_object(name)
@@ -89,81 +89,14 @@ module RobustExcelOle
       end
     end
 
-    # returns the contents of a range with a locally defined name
-    # evaluates the formula if the contents is a formula
-    # if the name could not be found or the range or value could not be determined,
-    # then return default value, if provided, raise error otherwise
-    # @param  [String]      name      the name of a range
-    # @param  [Hash]        opts      the options
-    # @option opts [Symbol] :default  the default value that is provided if no contents could be returned
-    # @return [Variant] the contents of a range with given name
-    def namevalue(name, opts = { :default => :__not_provided })
-      return namevalue_glob(name, opts) if self.is_a?(Workbook)
-      begin
-        ole_range = self.Range(name)
-      rescue # WIN32OLERuntimeError, VBAMethodMissingError, Java::OrgRacobCom::ComFailException 
-        return opts[:default] unless opts[:default] == :__not_provided
-        raise NameNotFound, "name #{name.inspect} not in #{self.inspect}"
-      end
-      begin
-        worksheet = self if self.is_a?(Worksheet)
-        #value = ole_range.Value
-        value = if !::RANGES_JRUBY_BUG
-          ole_range.Value
-        else
-          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 
-        return opts[:default] unless opts[:default] == :__not_provided
-        raise RangeNotEvaluatable, "cannot determine value of range named #{name.inspect} in #{self.inspect}"
-      end
-      if value == -2146828288 + RobustExcelOle::XlErrName
-        return opts[:default] unless opts[:default] == __not_provided
-        raise RangeNotEvaluatable, "cannot evaluate range named #{name.inspect} in #{File.basename(workbook.stored_filename).inspect rescue nil}"
-      end
-      return opts[:default] unless (opts[:default] == :__not_provided) || value.nil?
-      value
-    end
-
-    # 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   
-    # @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) 
-        ole_range = self.Range(name)
-      rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException, VBAMethodMissingError
-        raise NameNotFound, "name #{name.inspect} not in #{self.inspect}"
-      end
-      begin
-        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_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)
-            end
-          end
-        end
-        value
-      rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException
-        raise RangeNotEvaluatable, "cannot assign value to range named #{name.inspect} in #{self.inspect}"
-      end
-    end
-
     # @private
     def nameval(name, opts = { :default => :__not_provided })   # :deprecated: #
-      namevalue_glob(name, opts)
+      namevalue_global(name, opts)
     end
 
     # @private
     def set_nameval(name, value)        # :deprecated: #
-      set_namevalue_glob(name, value)
+      set_namevalue_global(name, value)
     end
 
     # @private

data/lib/robust_excel_ole/version.rb

@@ -1,3 +1,3 @@
 module RobustExcelOle
-  VERSION = "1.26"
+  VERSION = "1.31"
 end

data/lib/robust_excel_ole/workbook.rb

@@ -11,14 +11,14 @@ module RobustExcelOle
 
   class Workbook < RangeOwners
 
-    #include General 
-    
     attr_reader :ole_workbook
     attr_reader :excel
     attr_reader :stored_filename
 
     alias ole_object ole_workbook
 
+    using ToReoRefinement
+
     CORE_DEFAULT_OPEN_OPTS = {
       :default => {:excel => :current}, 
       :force => {},
@@ -42,7 +42,7 @@ module RobustExcelOle
 
 
     # opens a workbook.
-    # @param [String] file_or_workbook a file name or WIN32OLE workbook
+    # @param [String,Pathname] file_or_workbook a file name (string or pathname) or WIN32OLE workbook
     # @param [Hash] opts the options
     # @option opts [Hash] :default or :d
     # @option opts [Hash] :force or :f
@@ -158,7 +158,7 @@ module RobustExcelOle
         @excel = excel_class.new(ole_excel)
         filename = @ole_workbook.Fullname.tr('\\','/') 
       else
-        filename = file_or_workbook            
+        filename = file_or_workbook
         ensure_workbook(filename, opts)        
       end      
       apply_options(filename, opts)
@@ -235,13 +235,12 @@ module RobustExcelOle
       raise ExcelREOError, "Excel is not alive" unless @excel && @excel.alive?
     end
 
-
     # @private    
-    def ensure_workbook(filename, options)  
+    def ensure_workbook(filename, options)
       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 && 
+      if options[:if_unsaved]==:accept && alive? && 
         ((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
@@ -254,7 +253,7 @@ module RobustExcelOle
       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]
+        open_or_create_workbook(filename,options) if (!options[:read_only].nil?) && options[:read_only] != @ole_workbook.ReadOnly
       else
         if (excel_option.nil? || excel_option == :current) &&  
           !(::CONNECT_JRUBY_BUG && filename[0] == '/')
@@ -270,7 +269,6 @@ module RobustExcelOle
     # 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
         ensure_workbook(filename, options) 
       end
@@ -327,7 +325,7 @@ module RobustExcelOle
     def manage_blocking_or_unsaved_workbook(filename, options)
       filename = General.absolute_path(filename)
       filename = General.canonize(filename)
-      previous_file = General.canonize(@ole_workbook.Fullname)
+      previous_file = General.canonize(@ole_workbook.Fullname.gsub('\\','/'))
       obstructed_by_other_book = (File.basename(filename) == File.basename(previous_file)) &&
                                  (File.dirname(filename) != File.dirname(previous_file)) 
       if obstructed_by_other_book
@@ -341,11 +339,12 @@ module RobustExcelOle
       end        
     end
 
-    def manage_blocking_workbook(filename, options)
+    def manage_blocking_workbook(filename, options)     
+      blocked_filename = -> { General.canonize(@ole_workbook.Fullname.tr('\\','/')) }
       case options[:if_obstructed]
       when :raise
         raise WorkbookBlocked, "can't open workbook #{filename},
-        because it is being blocked by #{@ole_workbook.Fullname.tr('\\','/')} with the same name in a different path." +
+        because it is being blocked by #{blocked_filename.call} with the same name in a different path." +
         "\nHint: Use the option :if_blocked with values :forget or :save,
          to allow automatic closing of the old workbook (without or with saving before, respectively),
          before the new workbook is being opened."
@@ -355,7 +354,7 @@ 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: #{blocked_filename.call}" +
           "\nHint: Use the option :if_blocked => :save to save the workbook"
         else
           manage_forgetting_workbook(filename, options)
@@ -371,9 +370,14 @@ module RobustExcelOle
     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"
+        msg = if !options[:read_only].nil? && @ole_workbook.ReadOnly != options[:read_only]
+          "cannot change read-only mode of the workbook #{File.basename(filename).inspect}, because it contains unsaved changes"
+        else
+          "workbook is already open but not saved: #{File.basename(filename).inspect}"
+        end
+        raise WorkbookNotSaved, msg +
+        "\nHint: Use the option :if_unsaved with values :forget to close the unsaved workbook, 
+         :accept to let it open, or :save to save it, respectivly"
       when :forget
         manage_forgetting_workbook(filename, options)
       when :accept
@@ -406,7 +410,24 @@ module RobustExcelOle
       @ole_workbook = nil
       open_or_create_workbook(filename, options)
     end
-    
+
+    def explore_workbook_error(msg, want_change_readonly = nil)
+      if msg.message =~ /800A03EC/ && msg.message =~ /0x80020009/
+        # error message: 
+        # 'This workbook is currently referenced by another workbook and cannot be closed'
+        # 'Diese Arbeitsmappe wird momentan von einer anderen Arbeitsmappe verwendet und kann nicht geschlossen werden.'
+        if want_change_readonly==true
+          raise WorkbookLinked, "read-only mode of this workbook cannot be changed, because it is being used by another workbook"
+        elsif want_change_readonly.nil?
+          raise WorkbookLinked, "workbook is being used by another workbook"
+        else
+          raise UnexpectedREOError, "unknown WIN32OLERuntimeError:\n#{msg.message}"
+        end
+      else
+        raise UnexpectedREOError, "unknown WIN32OLERuntimeError:\n#{msg.message}"
+      end
+    end
+
     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 )
@@ -427,7 +448,8 @@ module RobustExcelOle
         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}"
+          want_change_readonly = !options[:read_only].nil? && (options[:read_only] != @ole_workbook.ReadOnly)
+          explore_workbook_error(msg, want_change_readonly)
         end
         begin
           # workaround for bug in Excel 2010: workbook.Open does not always return the workbook when given file name
@@ -522,7 +544,14 @@ module RobustExcelOle
   private
 
     def close_workbook
-      @ole_workbook.Close if alive?
+      #@ole_workbook.Close if alive?
+      if alive?
+        begin
+          @ole_workbook.Close 
+        rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
+          explore_workbook_error(msg)          
+        end
+      end      
       @ole_workbook = nil unless alive?
     end
 
@@ -557,11 +586,13 @@ module RobustExcelOle
     # 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
+    # @param [Hash]   opts        the options   
+    # @option opts [Boolean] :read_only true/false (default), force to open the workbook in read-only/read-write mode
+    # @option opts [Boolean] :writable  true (default)/false changes of the workbook shall be saved/not saved, 
+    #                                   and the workbook is being opened in read-only/read-write mode by default 
+    #                                   (when the workbook was not open before)
     # @option opts [Boolean] :keep_open whether the workbook shall be kept open after unobtrusively opening (default: false)
+    # @option opts [Variant] :if_closed  :current (default), :new or an Excel instance
     # @return [Workbook] a workbook
     def self.unobtrusively(file_or_workbook, opts = { }, &block)
       file = (file_or_workbook.is_a? WIN32OLE) ? file_or_workbook.Fullname.tr('\\','/') : file_or_workbook
@@ -591,20 +622,24 @@ module RobustExcelOle
       end
       open_opts = excel_opts.merge({:if_unsaved => :accept})
       begin
-        open_opts[:was_open] = nil
+        open_opts[:was_open] = nil  
         book = open(file, open_opts)
+        #book = open(file, :read_only => !opts[:writable]) if !opts[:writable].nil? && !open_opts[:was_open]
         was_visible = book.visible
         was_writable = book.writable
         was_saved = book.saved
         was_check_compatibility = book.check_compatibility
         was_calculation = book.excel.properties[:calculation]
+        #opts[:read_only] = !opts[:writable] unless (opts[:writable].nil? || open_opts[:was_open])
+        opts[:read_only] = !opts[:writable] unless (!opts[:read_only].nil? || opts[:writable].nil? || open_opts[:was_open])
         book.send :apply_options, file, opts
         yield book
       ensure
         if book && book.alive?
           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)
+          #if opts[:writable].nil? && opts[:was_open] && 
+          if  ((opts[:read_only] && was_writable) || (!opts[:read_only] && !was_writable))
             book.send :apply_options, file, opts.merge({:read_only => !was_writable, 
                                             :if_unsaved => (opts[:writable]==false ? :forget : :save)})
           end
@@ -904,14 +939,14 @@ module RobustExcelOle
     # @param [String] name the name of a range
     # @returns [Variant] the value of the range
     def [] name
-      namevalue_glob(name)
+      namevalue_global(name)
     end
 
     # sets the value of a range
     # @param [String]  name  the name of the range
     # @param [Variant] value the contents of the range
     def []= (name, value)
-      set_namevalue_glob(name, value)   
+      set_namevalue_global(name, value)   
     end
 
     # sets options
@@ -1026,11 +1061,14 @@ module RobustExcelOle
       '#<Workbook: ' + ('not alive ' unless alive?).to_s + (File.basename(self.filename) if alive?).to_s + " #{@excel}" + '>'
     end
 
+    using ParentRefinement
+    using StringRefinement
+
     # @private
     def self.excel_class    
       @excel_class ||= begin
         module_name = self.parent_name
-        "#{module_name}::Excel".constantize
+        "#{module_name}::Excel".constantize        
       rescue NameError => e
         # trace "excel_class: NameError: #{e}"
         Excel
@@ -1041,7 +1079,7 @@ module RobustExcelOle
     def self.worksheet_class    
       @worksheet_class ||= begin
         module_name = self.parent_name
-        "#{module_name}::Worksheet".constantize
+        "#{module_name}::Worksheet".constantize        
       rescue NameError => e
         Worksheet
       end
@@ -1094,6 +1132,10 @@ public
   class WorkbookNotSaved < WorkbookREOError        
   end
 
+  # @private
+  class WorkbookLinked < WorkbookREOError        
+  end
+
   # @private
   class WorkbookReadOnly < WorkbookREOError        
   end