robust_excel_ole 1.31 → 1.32

data/lib/robust_excel_ole/range_owners.rb

@@ -14,17 +14,15 @@ 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_global(name, opts = { :default => :__not_provided })
+    def namevalue_global(name, opts = { default: :__not_provided })
       name_obj = begin
-        name_object(name)
+        get_name_object(name)
       rescue NameNotFound => msg
-        return opts[:default] unless opts[:default] == :__not_provided
         raise
       end
       ole_range = name_obj.RefersToRange
       worksheet = self if self.is_a?(Worksheet)
       value = begin
-        #name_obj.RefersToRange.Value
         if !::RANGES_JRUBY_BUG       
           ole_range.Value
         else
@@ -33,11 +31,9 @@ module RobustExcelOle
         end
       rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException 
         sheet = if self.is_a?(Worksheet) then self
-                elsif self.is_a?(Workbook) then self.sheet(1)
-                elsif self.is_a?(Excel) then self.workbook.sheet(1)
+        elsif self.is_a?(Workbook) then self.sheet(1)
         end
         begin
-          #sheet.Evaluate(name_obj.Name).Value
           # does it result in a range?
           ole_range = sheet.Evaluate(name_obj.Name)
           if !::RANGES_JRUBY_BUG
@@ -64,33 +60,31 @@ module RobustExcelOle
     # @param [Variant] value the contents of the range
     # @option opts [Symbol] :color the color of the range when set
     def set_namevalue_global(name, value, opts = { }) 
-      begin
-        name_obj = begin
-          name_object(name)
-        rescue NameNotFound => msg
-          raise
-        end        
-        ole_range = name_object(name).RefersToRange
-        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
+      name_obj = begin
+        get_name_object(name)
+      rescue NameNotFound => msg
+        raise
+      end        
+      ole_range = name_obj.RefersToRange
+      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?(:pop) ? value[i][j] : value )
           end
         end
-        value
-      rescue #WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException
-        raise RangeNotEvaluatable, "cannot assign value to range named #{name.inspect} in #{self.inspect}"
       end
+      value
+    rescue #WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException
+      raise RangeNotEvaluatable, "cannot assign value to range named #{name.inspect} in #{self.inspect}\n#{$!.message}"
     end
 
     # @private
-    def nameval(name, opts = { :default => :__not_provided })   # :deprecated: #
+    def nameval(name, opts = { default: :__not_provided })   # :deprecated: #
       namevalue_global(name, opts)
     end
 
@@ -100,7 +94,7 @@ module RobustExcelOle
     end
 
     # @private
-    def rangeval(name, opts = { :default => :__not_provided })  # :deprecated: #
+    def rangeval(name, opts = { default: :__not_provided })  # :deprecated: #
       namevalue(name, opts)
     end
 
@@ -125,53 +119,45 @@ module RobustExcelOle
     # @params [Address] address of the range
     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_tool.as_r1c1(addr))
-      rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException
-        raise RangeNotEvaluatable, "cannot add name #{name.inspect} to range #{addr.inspect}"
-      end
+      self.Names.Add(name, nil, true, nil, nil, nil, nil, nil, nil, '=' + address_tool.as_r1c1(addr))
       name
+    rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException
+      raise RangeNotEvaluatable, "cannot add name #{name.inspect} to range #{addr.inspect}\n#{$!.message}"
     end
 
-    def set_name(name,row,column)     # :deprecated :#
-      add_name(name,row,column)
+    alias set_name add_name  # :deprecated :#
+
+    # renames an Excel object
+    # @param [String] old_name the previous name of the Excel object
+    # @param [String] new_name the new name of the Excel object
+    def rename_name(old_name, new_name)
+      item = get_name_object(old_name)
+      item.Name = new_name
+    rescue RobustExcelOle::NameNotFound
+      raise
+    rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
+      raise UnexpectedREOError, "name error with name #{old_name.inspect} in #{File.basename(self.stored_filename).inspect}\n#{$!.message}"
     end
 
-    # renames a range
-    # @param [String] name     the previous range name
-    # @param [String] new_name the new range name
-    def rename_range(name, new_name)
-      begin
-        item = self.Names.Item(name)
-      rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
-        raise NameNotFound, "name #{name.inspect} not in #{File.basename(self.stored_filename).inspect}"
-      end
-      begin
-        item.Name = new_name
-      rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
-        raise UnexpectedREOError, "name error in #{File.basename(self.stored_filename).inspect}"
-      end
-    end
+    alias rename_range rename_name  # :deprecated :#
 
-    # deletes a name of a range
-    # @param [String] name     the previous range name
-    # @param [String] new_name the new range name
+    # deletes a name of an Excel object
+    # @param [String] name    the name of the Excel object
     def delete_name(name)
-      begin
-        item = self.Names.Item(name)
-      rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException
-        raise NameNotFound, "name #{name.inspect} not in #{File.basename(self.stored_filename).inspect}"
-      end
-      begin
-        item.Delete
-      rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException
-        raise UnexpectedREOError, "name error in #{File.basename(self.stored_filename).inspect}"
-      end
-    end   
+      item = get_name_object(name)
+      item.Delete
+    rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException
+      raise UnexpectedREOError, "name error with name #{name.inspect} in #{File.basename(self.stored_filename).inspect}\n#{$!.message}"
+    end
+
+    # @return [Array] defined names
+    def names
+      self.Names.to_a.map(&:name)
+    end
 
   private
 
-    def name_object(name)
+    def get_name_object(name)
       self.Names.Item(name)
     rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException, VBAMethodMissingError
       begin

data/lib/robust_excel_ole/version.rb

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

data/lib/robust_excel_ole/workbook.rb

@@ -11,6 +11,8 @@ module RobustExcelOle
 
   class Workbook < RangeOwners
 
+    include Enumerable
+
     attr_reader :ole_workbook
     attr_reader :excel
     attr_reader :stored_filename
@@ -20,16 +22,16 @@ module RobustExcelOle
     using ToReoRefinement
 
     CORE_DEFAULT_OPEN_OPTS = {
-      :default => {:excel => :current}, 
-      :force => {},
-      :update_links => :never 
+      default: {excel: :current}, 
+      force: {},
+      update_links: :never 
     }.freeze
 
     DEFAULT_OPEN_OPTS = {
-      :if_unsaved    => :raise,
-      :if_obstructed => :raise,
-      :if_absent     => :raise,
-      :if_exists => :raise
+      if_unsaved: :raise,
+      if_obstructed: :raise,
+      if_absent: :raise,
+      if_exists: :raise
     }.merge(CORE_DEFAULT_OPEN_OPTS).freeze  
 
     ABBREVIATIONS = [
@@ -89,7 +91,7 @@ module RobustExcelOle
       process_options(opts)
       case file_or_workbook
       when NilClass
-        raise FileNameNotGiven, 'filename is nil' 
+        raise FileNameNotGiven, "filename is nil"
       when WIN32OLE
         file = file_or_workbook.Fullname.tr('\\','/') 
       when Workbook
@@ -101,7 +103,7 @@ module RobustExcelOle
         file = file_or_workbook.to_path
         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'
+        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)
@@ -110,14 +112,14 @@ module RobustExcelOle
         # if readonly is true, then prefer a book that is given in force_excel if this option is set              
         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
+            (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 => !(opts[:read_only]),
-                                  :prefer_excel    => (opts[:read_only] ? forced_excel : nil))
+            bookstore.fetch(file, prefer_writable: !(opts[:read_only]),
+                                  prefer_excel: (opts[:read_only] ? forced_excel : nil))
           end
         rescue
           raise
@@ -153,7 +155,7 @@ module RobustExcelOle
         ole_excel = begin 
           @ole_workbook.Application
         rescue WIN32OLERuntimeError
-          raise ExcelREOError, 'could not determine the Excel instance'
+          raise ExcelREOError, "could not determine the Excel instance\n#{$!.message}"
         end
         @excel = excel_class.new(ole_excel)
         filename = @ole_workbook.Fullname.tr('\\','/') 
@@ -182,7 +184,7 @@ module RobustExcelOle
       self.class.set_was_open(hash, value)
     end
 
-    def self.process_options(opts, proc_opts = {:use_defaults => true})
+    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)
@@ -224,9 +226,9 @@ module RobustExcelOle
       return if @excel && @excel.alive?
       excel_option = options[:force][:excel] || options[:default][:excel] || :current
       @excel = if excel_option == :new
-        excel_class.new(:reuse => false) 
+        excel_class.new(reuse: false) 
       elsif excel_option == :current
-        excel_class.new(:reuse => true)
+        excel_class.new(reuse: true)
       elsif excel_option.respond_to?(:to_reo)
         excel_option.to_reo.excel
       else
@@ -281,14 +283,14 @@ module RobustExcelOle
 
     # connects to an unknown workbook
     def connect(filename, options)   
-      workbooks_number = excel_class.excels_number==0 ? 0 : excel_class.current.Workbooks.Count
+      workbooks_number = excel_class.instance_count==0 ? 0 : excel_class.current.Workbooks.Count
       @ole_workbook = begin
         WIN32OLE.connect(General.absolute_path(filename))
       rescue
         if $!.message =~ /moniker/
           raise WorkbookConnectingBlockingError, "some workbook is blocking when connecting"
         else 
-          raise WorkbookConnectingUnknownError, "unknown error when connecting to a workbook"
+          raise WorkbookConnectingUnknownError, "unknown error when connecting to a workbook\n#{$!.message}"
         end
       end
       ole_excel = begin
@@ -297,7 +299,7 @@ module RobustExcelOle
         if $!.message =~ /dispid/
           raise WorkbookConnectingUnsavedError, "workbook is unsaved when connecting"
         else 
-          raise WorkbookConnectingUnknownError, "unknown error when connecting to a workbook"
+          raise WorkbookConnectingUnknownError, "unknown error when connecting to a workbook\n#{$!.message}"
         end
       end
       set_was_open options, (ole_excel.Workbooks.Count == workbooks_number)
@@ -355,7 +357,7 @@ module RobustExcelOle
       when :close_if_saved
         if !@ole_workbook.Saved
           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"
+          "\nHint: Use the option if_blocked: :save to save the workbook"
         else
           manage_forgetting_workbook(filename, options)
         end
@@ -406,7 +408,7 @@ module RobustExcelOle
     end
 
     def manage_new_excel(filename, options)
-      @excel = excel_class.new(:reuse => false)
+      @excel = excel_class.new(reuse: false)
       @ole_workbook = nil
       open_or_create_workbook(filename, options)
     end
@@ -420,50 +422,39 @@ module RobustExcelOle
           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
+      end
+      if msg.message !~ /800A03EC/ || msg.message !~ /0x80020009/ || want_change_readonly==false
         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 )
+                (options[:read_only].nil? || options[:read_only]==@ole_workbook.ReadOnly )
+      abs_filename = General.absolute_path(filename)
+      workbooks = begin 
+        @excel.Workbooks
+      rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
+        raise UnexpectedREOError, "cannot access workbooks: #{msg.message} #{msg.backtrace}"
+      end
       begin
-        abs_filename = General.absolute_path(filename)
-        begin
-          workbooks = @excel.Workbooks
-        rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
-          raise UnexpectedREOError, "cannot access workbooks: #{msg.message} #{msg.backtrace}"
-        end
-        begin
-          with_workaround_linked_workbooks_excel2007(options) do
-            # temporary workaround until jruby-win32ole implements named parameters (Java::JavaLang::RuntimeException (createVariant() not implemented for class org.jruby.RubyHash)
-            workbooks.Open(abs_filename, 
-                                      updatelinks_vba(options[:update_links]), 
-                                      options[:read_only] )
-          end
-        rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
-          # for Excel2007: for option :if_unsaved => :alert and user cancels: this error appears?
-          # if yes: distinguish these events
-          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
-          begin
-            @ole_workbook = workbooks.Item(File.basename(filename))
-          rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
-            raise UnexpectedREOError, "WIN32OLERuntimeError: #{msg.message}"
-          end
-        rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
-          raise UnexpectedREOError, "WIN32OLERuntimeError: #{msg.message} #{msg.backtrace}"
+        with_workaround_linked_workbooks_excel2007(options) do
+          # temporary workaround until jruby-win32ole implements named parameters (Java::JavaLang::RuntimeException (createVariant() not implemented for class org.jruby.RubyHash)
+          workbooks.Open(abs_filename, updatelinks_vba(options[:update_links]), options[:read_only] )
         end
+      rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
+        # for Excel2007: for option :if_unsaved => :alert and user cancels: this error appears?; distinguish these events
+        want_change_readonly = !options[:read_only].nil? && (options[:read_only] != @ole_workbook.ReadOnly)
       end
-    end    
-           
+      # workaround for bug in Excel 2010: workbook.Open does not always return the workbook when given file name
+      @ole_workbook = begin
+        workbooks.Item(File.basename(filename))
+      rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
+        raise UnexpectedREOError, "WIN32OLERuntimeError: #{msg.message}"
+      end
+    end  
+
     # translating the option UpdateLinks from REO to VBA
     # setting UpdateLinks works only if calculation mode is automatic,
     # parameter 'UpdateLinks' has no effect
@@ -502,7 +493,7 @@ module RobustExcelOle
     # @param [String] filename the filename under which the new workbook should be saved
     # @param [Hash] opts the options as in Workbook::open
     def self.create(filename, opts = { })
-      open(filename, :if_absent => :create)
+      open(filename, if_absent: :create)
     end
 
     # closes the workbook, if it is alive
@@ -517,34 +508,30 @@ module RobustExcelOle
     #                      :alert or :excel -> gives control to excel
     # @raise WorkbookNotSaved if the option :if_unsaved is :raise and the workbook is unsaved
     # @raise OptionInvalid if the options is invalid
-    def close(opts = {:if_unsaved => :raise})
-      if alive? && !@ole_workbook.Saved && writable
-        case opts[:if_unsaved]
-        when :raise
-          raise WorkbookNotSaved, "workbook is unsaved: #{File.basename(self.stored_filename).inspect}" +
-          "\nHint: Use option :save or :forget to close the workbook with or without saving"
-        when :save
-          save
-          close_workbook
-        when :forget
-          @excel.with_displayalerts(false) { close_workbook }
-        when :keep_open
-          # nothing
-        when :alert, :excel
-          @excel.with_displayalerts(true) { close_workbook }
-        else
-          raise OptionInvalid, ":if_unsaved: invalid option: #{opts[:if_unsaved].inspect}" +
-          "\nHint: Valid values are :raise, :save, :keep_open, :alert, :excel"
-        end
-      else
+    def close(opts = {if_unsaved: :raise})
+      return close_workbook unless (alive? && !@ole_workbook.Saved && writable)
+      case opts[:if_unsaved]
+      when :raise
+        raise WorkbookNotSaved, "workbook is unsaved: #{File.basename(self.stored_filename).inspect}" +
+        "\nHint: Use option :save or :forget to close the workbook with or without saving"
+      when :save
+        save
         close_workbook
+      when :forget
+        @excel.with_displayalerts(false) { close_workbook }
+      when :keep_open
+        # nothing
+      when :alert, :excel
+        @excel.with_displayalerts(true) { close_workbook }
+      else
+        raise OptionInvalid, ":if_unsaved: invalid option: #{opts[:if_unsaved].inspect}" +
+        "\nHint: Valid values are :raise, :save, :keep_open, :alert, :excel"
       end
     end
 
   private
 
     def close_workbook
-      #@ole_workbook.Close if alive?
       if alive?
         begin
           @ole_workbook.Close 
@@ -568,19 +555,19 @@ module RobustExcelOle
     end
 
     def for_reading(opts = { }, &block)
-      unobtrusively({:writable => false}.merge(opts), &block)
+      unobtrusively({writable: false}.merge(opts), &block)
     end
 
     def for_modifying(opts = { }, &block)
-      unobtrusively({:writable => true}.merge(opts), &block)
+      unobtrusively({writable: true}.merge(opts), &block)
     end
 
     def self.for_reading(arg, opts = { }, &block)
-      unobtrusively(arg, {:writable => false}.merge(opts), &block)
+      unobtrusively(arg, {writable: false}.merge(opts), &block)
     end
 
     def self.for_modifying(arg, opts = { }, &block)
-      unobtrusively(arg, {:writable => true}.merge(opts), &block)
+      unobtrusively(arg, {writable: true}.merge(opts), &block)
     end
 
     # allows to read or modify a workbook such that its state remains unchanged
@@ -608,29 +595,27 @@ module RobustExcelOle
 
     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] 
+      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) 
+        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]}}
+        {force: {excel: opts[:if_closed]}}
       else
-        {:force => {:excel => opts[:force][:excel]}, :default => {:excel => opts[:default][:excel]}}
+        {force: {excel: opts[:force][:excel]}, default: {excel: opts[:default][:excel]}}
       end
-      open_opts = excel_opts.merge({:if_unsaved => :accept})
+      open_opts = excel_opts.merge({if_unsaved: :accept})
       begin
         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
@@ -638,10 +623,9 @@ module RobustExcelOle
         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[: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)})
+            book.send :apply_options, file, opts.merge({read_only: !was_writable, 
+                                            if_unsaved: (opts[:writable]==false ? :forget : :save)})
           end
           was_open = open_opts[:was_open]
           if was_open
@@ -661,20 +645,20 @@ module RobustExcelOle
     # @options options
     def reopen(options = { })
       book = self.class.open(@stored_filename, options)
-      raise WorkbookREOError('cannot reopen book') unless book && book.alive?
+      raise WorkbookREOError("cannot reopen workbook\n#{$!.message}") unless book && book.alive?
       book
     end
 
     # simple save of a workbook.
     # @return [Boolean] true, if successfully saved, nil otherwise
     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   
+      raise ObjectNotAlive, "workbook is not alive" unless alive?
+      raise WorkbookReadOnly, "Not opened for writing (opened with :read_only option)" if @ole_workbook.ReadOnly   
       begin
         @ole_workbook.Save
       rescue WIN32OLERuntimeError, Java::OrgRacobCom::ComFailException => msg
         if msg.message =~ /SaveAs/ && msg.message =~ /Workbook/
-          raise WorkbookNotSaved, 'workbook not saved'
+          raise WorkbookNotSaved, "workbook not saved"
         else
           raise UnexpectedREOError, "unknown WIN32OLERuntimeError:\n#{msg.message}"
         end
@@ -700,64 +684,72 @@ module RobustExcelOle
     #                                          otherwise raises an exception   
     # @return [Workbook], the book itself, if successfully saved, raises an exception otherwise
     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 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)
-      self.class.process_options(options)      
-      if File.exist?(file)
-        case options[:if_exists]
-        when :overwrite
-          if file == self.filename
-            save
-            return self
-          else
-            begin
-              File.delete(file)
-            rescue Errno::EACCES
-              raise WorkbookBeingUsed, 'workbook is open and being used in an Excel instance'
-            end
-          end
-        when :alert, :excel
-          @excel.with_displayalerts true do
-            save_as_workbook(file, options)
-          end
-          return self
-        when :raise
-          raise FileAlreadyExists, "file already exists: #{File.basename(file).inspect}" +
-          "\nHint: Use option :if_exists => :overwrite, if you want to overwrite the file" 
+      self.class.process_options(options)
+      begin  
+        saveas_manage_if_exists(file, options)
+        saveas_manage_if_blocked(file, options)
+        save_as_workbook(file, options)
+      rescue AlreadyManaged
+        nil
+      end
+      self
+    end
+
+  private
+
+    def saveas_manage_if_exists(file, options)
+      return unless File.exist?(file)
+      case options[:if_exists]
+      when :overwrite
+        if file == self.filename
+          save
+          raise AlreadyManaged
         else
-          raise OptionInvalid, ":if_exists: invalid option: #{options[:if_exists].inspect}" +
-          "\nHint: Valid values are :raise, :overwrite, :alert, :excel"
+          begin
+            File.delete(file)
+          rescue Errno::EACCES
+            raise WorkbookBeingUsed, "workbook is open and being used in an Excel instance"
+          end
         end
+      when :alert, :excel
+        @excel.with_displayalerts(true){ save_as_workbook(file, options) }
+        raise AlreadyManaged
+      when :raise
+        raise FileAlreadyExists, "file already exists: #{File.basename(file).inspect}" +
+        "\nHint: Use option if_exists: :overwrite, if you want to overwrite the file" 
+      else
+        raise OptionInvalid, ":if_exists: invalid option: #{options[:if_exists].inspect}" +
+        "\nHint: Valid values are :raise, :overwrite, :alert, :excel"
       end
+    end
+
+    def saveas_manage_if_blocked(file, options)
       other_workbook = @excel.Workbooks.Item(File.basename(file)) rescue nil
-      if other_workbook && self.filename != other_workbook.Fullname.tr('\\','/')
-        case options[:if_obstructed]
-        when :raise
-          raise WorkbookBlocked, "blocked by another workbook: #{other_workbook.Fullname.tr('\\','/')}" +
-          "\nHint: Use the option :if_blocked with values :forget or :save to
-           close or save and close the blocking workbook"
-        when :forget
-          # nothing
-        when :save
-          other_workbook.Save
-        when :close_if_saved
-          unless other_workbook.Saved
-            raise WorkbookBlocked, "blocking workbook is unsaved: #{File.basename(file).inspect}" +
-            "\nHint: Use option :if_blocked => :save to save the blocking workbooks"
-          end
-        else
-          raise OptionInvalid, ":if_blocked: invalid option: #{options[:if_obstructed].inspect}" +
-          "\nHint: Valid values are :raise, :forget, :save, :close_if_saved"
+      return unless other_workbook && self.filename != other_workbook.Fullname.tr('\\','/')
+      case options[:if_obstructed]
+      when :raise
+        raise WorkbookBlocked, "blocked by another workbook: #{other_workbook.Fullname.tr('\\','/')}" +
+        "\nHint: Use the option :if_blocked with values :forget or :save to
+         close or save and close the blocking workbook"
+      when :forget
+        # nothing
+      when :save
+        other_workbook.Save
+      when :close_if_saved
+        unless other_workbook.Saved
+          raise WorkbookBlocked, "blocking workbook is unsaved: #{File.basename(file).inspect}" +
+          "\nHint: Use option if_blocked: :save to save the blocking workbooks"
         end
-        other_workbook.Close
+      else
+        raise OptionInvalid, "if_blocked: invalid option: #{options[:if_obstructed].inspect}" +
+        "\nHint: Valid values are :raise, :forget, :save, :close_if_saved"
       end
-      save_as_workbook(file, options)
-      self
-    end    
-
-  private
+      other_workbook.Close
+    end
 
     def save_as_workbook(file, options)  
       dirname, basename = File.split(file)
@@ -778,6 +770,9 @@ module RobustExcelOle
       end
     end
 
+    class AlreadyManaged < Exception
+    end
+
     def store_myself
       bookstore.store(self)
       @stored_filename = filename
@@ -787,7 +782,7 @@ module RobustExcelOle
 
     # closes a given file if it is open
     # @options opts [Symbol] :if_unsaved
-    def self.close(file, opts = {:if_unsaved => :raise})
+    def self.close(file, opts = {if_unsaved: :raise})
       book = begin
         bookstore.fetch(file)
         rescue
@@ -825,21 +820,20 @@ module RobustExcelOle
       @ole_workbook.Worksheets.Count
     end
 
+    # @return [Enumerator] traversing all worksheet objects
     def each
-      @ole_workbook.Worksheets.each do |sheet|
-        yield worksheet_class.new(sheet)
+      if block_given?
+        @ole_workbook.Worksheets.lazy.each do |ole_worksheet|
+          yield worksheet_class.new(ole_worksheet)
+        end
+      else
+        to_enum(:each).lazy
       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|
+      @ole_workbook.Worksheets.lazy.each do |sheet|
         yield worksheet_class.new(sheet), i
         i += 1
       end
@@ -880,7 +874,7 @@ module RobustExcelOle
           end
         end
       rescue # WIN32OLERuntimeError, NameNotFound, Java::OrgRacobCom::ComFailException
-        raise WorksheetREOError, "could not add given worksheet #{sheet.inspect}"
+        raise WorksheetREOError, "could not add given worksheet #{sheet.inspect}\n#{$!.message}"
       end
       new_sheet = worksheet_class.new(ole_workbook.Activesheet)
       new_sheet.name = new_sheet_name if new_sheet_name
@@ -924,7 +918,7 @@ module RobustExcelOle
     def range(name_or_worksheet, name_or_address = :__not_provided, address2 = :__not_provided)
       if name_or_worksheet.respond_to?(:gsub)
         name = name_or_worksheet
-        RobustExcelOle::Range.new(name_object(name).RefersToRange)
+        RobustExcelOle::Range.new(get_name_object(name).RefersToRange)
       else 
         begin 
           worksheet = name_or_worksheet.to_reo
@@ -953,7 +947,7 @@ module RobustExcelOle
     # @param [Hash] opts
     def for_this_workbook(opts)
       return unless alive?
-      self.class.process_options(opts, :use_defaults => false)
+      self.class.process_options(opts, use_defaults: false)
       self.send :apply_options, @stored_filename, opts
     end
 
@@ -1058,7 +1052,8 @@ module RobustExcelOle
 
     # @private
     def inspect    
-      '#<Workbook: ' + ('not alive ' unless alive?).to_s + (File.basename(self.filename) if alive?).to_s + " #{@excel}" + '>'
+      #{}"#<Workbook: #{("not alive " unless alive?)} #{(File.basename(self.filename) if alive?)} #{@excel}>"
+      "#<Workbook: #{(alive? ? File.basename(self.filename) : "not alive")} #{@excel} >"
     end
 
     using ParentRefinement
@@ -1100,23 +1095,20 @@ module RobustExcelOle
   private
 
     def method_missing(name, *args) 
-      if name.to_s[0,1] =~ /[A-Z]/
-        raise ObjectNotAlive, 'method missing: workbook not alive' unless alive?
-        if ::ERRORMESSAGE_JRUBY_BUG 
-          begin
-            @ole_workbook.send(name, *args)
-          rescue Java::OrgRacobCom::ComFailException 
-            raise VBAMethodMissingError, "unknown VBA property or method #{name.inspect}"
-          end
-        else
-          begin
-            @ole_workbook.send(name, *args)
-          rescue NoMethodError 
-            raise VBAMethodMissingError, "unknown VBA property or method #{name.inspect}"
-          end
+      super unless name.to_s[0,1] =~ /[A-Z]/
+      raise ObjectNotAlive, 'method missing: workbook not alive' unless alive?
+      if ::ERRORMESSAGE_JRUBY_BUG 
+        begin
+          @ole_workbook.send(name, *args)
+        rescue Java::OrgRacobCom::ComFailException 
+          raise VBAMethodMissingError, "unknown VBA property or method #{name.inspect}"
         end
       else
-        super
+        begin
+          @ole_workbook.send(name, *args)
+        rescue NoMethodError 
+          raise VBAMethodMissingError, "unknown VBA property or method #{name.inspect}"
+        end
       end
     end