robust_excel_ole 1.8 → 1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2bdbfacd559753a2e1126c1ff1a28520a6c6cd57
-  data.tar.gz: a5cdf8708f6862cda1630fc9152f65a498e446b0
+SHA256:
+  metadata.gz: 3cf45dfa8d36893f06b8196d99990c94b76056fdfd8b98e2a1cff18f11dedec5
+  data.tar.gz: 2fb8ee7deb7bb700c9a7557340933b0a60a6ee38a8eaff9ed2c2f4b4669cadc0
 SHA512:
-  metadata.gz: 830ff59640559e837e7d15daf2ee5ec18c734aaebaba3a56189ea837f755deb8d4e7f7bf06aa01365ea59f633837ef4faa27bf1951a6af0f7ba834c083fd0e79
-  data.tar.gz: 4aea6e53ba40c1c14a26ce2bef43591e0a39194d65a1b90b4acc6623206bfad9796b8a69351d35aa7f99bca2201f8b23eac55a951f0d23b42a34f9f93fd91b03
+  metadata.gz: 6b8c23bf581b8ec11b9e510bf0bf805e2309a089a307c01bdcaf4aead8dc1aa31becd972e94beedb5e7ac82183ac4f84bd0c5ea6883a4a15baa2d2f95fd13dba
+  data.tar.gz: 6958f89f6a6204f359a2f16469ca602a33b1572588b31944a073ffbc48936a9e9412edd4b742bb57ecff4e3b96756e99258924f60d5d2b7aaf8fefabafc0c697

data/Changelog

@@ -1,6 +1,14 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
+## [1.9]
+
+### Added
+  - Workbook#create
+  - Excel#workbooks, each_workbook, each_workbook_with_index
+  - Address#int_range,#r1c1,#a1
+  - ReoCommon::RangeOwners#add_name: allowing infinite ranges
+
 ## [1.6]
 
 ### Added

data/README.rdoc

@@ -28,13 +28,17 @@ RobustExcelOle can be used either for scripts
   require 'robust_excel_ole'
   include RobustExcelOle
 
-or as a console 
+or as a console. If you want to use RobustExcelOle as a console, you go (using 'cd') into the gem path that you find with help of 
+
+  gem env
+
+and go into the path of the gem 'robust_excel_ole'. There you start the console via the command
 
   reo
 
 The call of the console will include RobustExcelOle for you.
 
-The following examples can be used for both scripts and console. If you are in the path of the gem and start the console, you can just put these examples.
+The following examples can be used for both scripts and console. If you have started the console in the gem path, you can just put these examples.
 
 == Description  
 
@@ -100,7 +104,11 @@ RobustExcelOle allows unobtrusively reading and modifying workbooks, i.e. access
     # do something
   end
 
-=== More features when opening, modifying, saving and closing workbooks
+You can also create a new, empty workbook. 
+
+  Workbook.create('spec/data/new_workbook.xls', :visible => true)
+
+=== More features when opening, modifying, creating saving and closing workbooks
 
 We can open the workbook using a block, similar to, e.g., +File.open+. 
 
@@ -174,6 +182,12 @@ For hard terminating all Excel processes we can use
 
 For more details about creating Excel instances see README_excel[https://github.com/Thomas008/robust_excel_ole/blob/master/README/README_excel_rdoc]
 
+=== Generating a new workbook
+
+You can creata a new, empty workbook by
+
+  Excel.generate_workbook('spec/data/new_workbook.xls')
+
 === Opening workbooks in several Excel instances
 
 RobustExcelOle enables opening and processing workbooks in several Excel instances. Using more than one Excel process allows, e.g., running a script that operates in one Excel instance, while a user (or another script) modifies workbooks in another Excel instance. 

data/docs/README_excel.rdoc

@@ -101,6 +101,29 @@ You can set options for all workbooks of an Excel instance.
 
   excel.for_all_workooks(:visible => true, :read_only => true)
 
+
+=== Showing and traversing through all workbooks
+
+You can yield an array of all Workbook objects of an Excel instance.
+
+  excel.workbooks
+
+You can access all Workbook objects by using the methods Excel#each_workbook and Excel#each_workbook_with_index. Here are some examples:
+  
+  excel.each_workook {|w| puts w.filename}
+
+and
+
+  excel.each_workbook.with_index {|w,i| puts w,i }
+
+With help of these methods you can also supply options, e.g. without a block,
+
+  excel.each_workbook(:visible => true) 
+
+or, with a block,
+
+  excel.each_workbook(:visible => true) {|w| puts w}
+
 === Bringing an Excel instance to the foreground
 
   excel1.focus

data/docs/README_ranges.rdoc

@@ -142,15 +142,21 @@ For example, you can access a range consisting of one cell by providing the row
 
   range = sheet.range([1,1])
 
-Using the A1-format you write
+Using the A1-format and R1C1-format you write
 
   range = sheet.range("A1") 
 
+and
+
+  range = sheet.range("Z1S1")
+
+respectively.
+
 You can access a rectangular range by providing the row and column of the top left cell and the row and column of the bottum right cell. 
 
   range = sheet.range([1..3,1..4])
 
-or using the a1-format
+or using the A1-format.
 
   range = sheet.range([1..3,"A".."D"])
 
@@ -158,6 +164,28 @@ or
 
   range = sheet.range("A1:D3")
 
+or using the R1C1-format
+
+  range = sheet.range("Z1S1:Z3S4")
+
+Infinite ranges are defined, e.g., by setting the rows or columns to +nil+
+
+  range = sheet.range([1..3,nil])
+  range = sheet.range([nil,"A".."B"])
+
+Using the A1-format you write
+
+  range = sheet.range("1:3")
+  range = sheet.range("A:B")
+
+You can also apply relative references by using brackets, e.g.
+
+  range = sheet.range("Z[1]S1:Z3S[4]")
+
+or
+
+  range = sheet.range([[1]..3,2..[4]])
+
 You get the values of the range as flat array with help of
 
   range.values
@@ -194,13 +222,53 @@ Moreover, you can state, whether you want to copy the values only, and whether y
   
 Note that when you don't copy the values only but all formating as well, and you either copy into another Excel instance or transpose the range, the clipboard is being used. 
 
-=== Naming a cell
+=== Naming a range
+
+You can (re-) define a name referring to a range by stating its name, and the address. The address is given by integer-range-format, r1c1-format or a1-format. For example, you can define a name for a rectangular range by
 
-You can (re-) define a name referring to a cell with help of VBA methods by stating its name, and the row and the column of the cell.
+  book.add_name("name",[1..2,3..5])
+
+or
+
+  book.add_name("name","Z1S3:Z2S5")
+
+or
+
+  book.add_name("name", "C1:E2")
+
+Similarly you can define a name referring to a cell
 
   book.add_name("name",[1,1])
 
-Most methods can be done for Workbook, Worksheet, and Excel objects.
+or
+
+  book.add_name("name","Z1S1")
+
+or
+
+  book.add_name("name","A1")
+
+and infinite ranges
+
+  book.add_name("name",[1..2,nil])
+
+or
+
+  book.add_name("name", "Z1:Z2")
+
+or
+
+  book.add_name("name","1:2")
+
+Furthermore, you can define a name using relative references with the r1c1-format.
+
+  book.add_name("name", "Z1S[1]:Z[2]S4")
+
+or
+
+  book.add_name("name", [1..[2],[1]..4])
+
+You can do the same for an worksheet or Excel object.
 
 === Reading and writing the contents of a named range in a workbook.
 

data/examples/modifying_sheets/example_add_names.rb

@@ -0,0 +1,57 @@
+# example_naming.rb: 
+# each cell is named with the name equaling its value unless it is empty or not a string
+# the contents of each cell is copied
+# the new workbook's name is extended by the suffix "_named"
+
+require File.expand_path('../../lib/robust_excel_ole', File.dirname(__FILE__))
+require File.join(File.dirname(File.expand_path(__FILE__)), '../../spec/helpers/create_temporary_dir')
+require "fileutils"
+
+include RobustExcelOle
+
+begin
+  @id2exl = ["house", "tree", "cat", "mouse", "elephant", "yes", "no"]
+  column_ids = [2,4,6]
+  dir = File.expand_path('../../spec/data', File.dirname(__FILE__))
+  workbook_name = 'workbook.xls'
+  filename = dir + "/" + workbook_name
+  puts "filename: #{filename}"
+
+  Excel.close_all if_unsaved: :forget
+  book = Workbook.new filename, if_absent: :create, visible: true, if_unsaved: :accept
+  sheet = book.sheet(1)
+  puts "book: #{book}"
+  puts "sheet: #{sheet}"
+
+  # book.Names.Add("µ",  RefersToR1C1Local:"=Z")
+  # book.Names.Add("µ_1", RefersToR1C1Local:"=Z(-1)")
+
+  def define_columns sheet, columns_ids
+    puts "define_columns:"
+    first_column = sheet.range("A")
+    puts "first_column: #{first_column}"
+
+    columns_ids.each_with_index do |id,idx|
+      puts "id: #{id}"
+      puts "idx: #{idx}"
+
+      nam = @id2exl[id]
+      puts "nam: #{nam}"
+      colnr = idx+1
+      puts "colnr: #{colnr}"
+      sheet[1,colnr] = nam
+      puts "sheet[1,colnr]: #{sheet[1,colnr].Value}"
+      sheet.add_name(nam,[nil,colnr])
+      puts "sheet.Range().Address: #{sheet.Range(nam).Address}"
+      #sheet.add_name(nam,"A")
+      # blatt.Names.Add(Name: nam, RefersTo: "="+erste_spalte.Offset(0,idx).Address)
+    end
+  end
+
+  define_columns sheet, column_ids
+
+  
+  # book.save
+
+end
+

data/examples/modifying_sheets/example_adding_sheets.rb

@@ -57,7 +57,7 @@ begin
   begin
     @book.add_sheet(sheet, :as => 'second_sheet_copy')
   rescue NameAlreadyExists => msg
-    puts "error: add_sheet: #{msg.message}"
+    puts "results in an error: add_sheet: #{msg.message}"
   end    
 
   @book.close(:if_unsaved => :forget)   # close the book without saving it

data/examples/open_save_close/example_if_obstructed_closeifsaved.rb

@@ -32,5 +32,5 @@ begin
   new_book.close                                 # close the books                  
 ensure
   Excel.kill_all                         # close all workbooks, quit Excel application
-  rm_tmp(dir)
+  #rm_tmp(dir)
 end

data/examples/open_save_close/example_if_unsaved_forget.rb

@@ -1,4 +1,4 @@
-# example_ifunsaved_forget.rb:
+# example_if_unsaved_forget.rb:
 # open with :if_unsaved => :forget, :new_excel, close with :if_unsaved => :save 
 
 require File.expand_path('../../lib/robust_excel_ole', File.dirname(__FILE__))

data/examples/open_save_close/example_reuse.rb

@@ -13,7 +13,7 @@ begin
   file_name2 = dir + 'different_workbook.xls'
   file_name3 = dir + 'different_workbook.xls'
   file_name4 = dir + 'book_with_blank.xls'
-  book1 = Workbook.open(file_name1)             # open a book in a new Excel instance since no Excel is open
+  book1 = Workbook.open(file_name1)         # open a book in a new Excel instance since no Excel is open
   book1.excel.visible = true                # make current Excel visible
   sleep 2
   book2 = Workbook.open(file_name2)             # open a new book in the same Excel instance

data/lib/robust_excel_ole.rb

@@ -1,5 +1,7 @@
 require 'win32ole'
 require File.join(File.dirname(__FILE__), 'robust_excel_ole/reo_common')
+require File.join(File.dirname(__FILE__), 'robust_excel_ole/range_owners')
+require File.join(File.dirname(__FILE__), 'robust_excel_ole/address')
 require File.join(File.dirname(__FILE__), 'robust_excel_ole/general')
 require File.join(File.dirname(__FILE__), 'robust_excel_ole/excel')
 require File.join(File.dirname(__FILE__), 'robust_excel_ole/bookstore')

data/lib/robust_excel_ole/address.rb

@@ -0,0 +1,114 @@
+# -*- coding: utf-8 -*-
+
+module RobustExcelOle
+
+  class Address < REOCommon
+
+    def self.new(r1c1_letters)
+      @@row_letter = r1c1_letters[0..0]
+      @@col_letter = r1c1_letters[1..1]
+    end
+
+    # address formats taht are valid:
+    #   r1c1-format: e.g. "Z3S1", "Z3S1:Z5S2", "Z[3]S1", "Z3S[-1]:Z[5]S1", "Z[3]", "S[-2]"
+    #                      infinite ranges are not possible, e.g. "Z3:Z5", "S2:S5", "Z2", "S3", "Z[2]" 
+    #   int_range: e.g. [3,1], [3,"A"], [3..5,1..2], [3..5, "A".."B"], 
+    #                   [3..4, nil], [nil, 2..4], [2,nil], [nil,4]
+    #   a1-format: e.g. "A3", "A3:B5", "A:B", "3:5", "A", "3"
+
+    def self.r1c1(address)
+      transform_address(address,:r1c1)
+    end
+
+    def self.a1(address)
+      transform_address(address,:a1)
+    end
+
+    # valid address formats: e.g. [3,1], [3,"A"], [3..5,1..2], [3..5, "A".."B"], 
+    #                             [3..4, nil], [nil, 2..4], [2,nil], [nil,4]
+    def self.int_range(address)
+      transform_address(address,:int_range)
+    end
+
+  private
+
+    def self.transform_address(address, format)
+      address = address.is_a?(Array) ? address : [address]
+      raise AddressInvalid, "address #{address.inspect} has more than two components" if address.size > 2
+      begin
+        if address.size == 1
+          comp1, comp2 = address[0].split(':')
+          a1_expr = /^(([A-Z]+[0-9]+)|([A-Z]+$)|([0-9]+))$/
+          is_a1 = comp1 =~ a1_expr && (comp2.nil? || comp2 =~ a1_expr)
+          r1c1_expr = /^(([A-Z]\[?-?[0-9]+\]?[A-Z]\[?-?[0-9]+\]?)|([A-Z]\[?-?[0-9]+\]?)|([A-Z]\[?-?[0-9]+\]?))$/
+          is_r1c1 = comp1 =~ r1c1_expr && (comp2.nil? || comp2 =~ r1c1_expr) && (not is_a1) 
+          raise AddressInvalid, "address #{address.inspect} not in A1- or r1c1-format" unless (is_a1 || is_r1c1)
+          return address[0].gsub('[','(').gsub(']',')') if (is_a1 && format==:a1) || (is_r1c1 && format==:r1c1)         
+          given_format = (is_a1) ? :a1 : :r1c1
+          row_comp1, col_comp1 = analyze(comp1,given_format)
+          row_comp2, col_comp2 = analyze(comp2,given_format) unless comp2.nil?
+          address_comp1 = comp2 && (not row_comp1.nil?) ? (row_comp1 .. row_comp2) : row_comp1
+          address_comp2 = comp2 && (not col_comp1.nil?) ? (col_comp1 .. col_comp2) : col_comp1          
+        else
+          address_comp1, address_comp2 = address      
+        end
+        address_comp1 = address_comp1..address_comp1 if (address_comp1.is_a?(Integer) || address_comp1.is_a?(String) || address_comp1.is_a?(Array))
+        address_comp2 = address_comp2..address_comp2 if (address_comp2.is_a?(Integer) || address_comp2.is_a?(String) || address_comp2.is_a?(Array)) 
+        #raise unless address_comp1.nil? || address_comp1.begin.to_i!=0 || address_comp1.begin.empty?
+        rows = unless address_comp1.nil? || address_comp1.begin == 0 # || address_comp1.begin.to_i==0          
+          address_comp1.begin..address_comp1.end
+        end
+        columns = unless address_comp2.nil?
+          if address_comp2.begin.is_a?(String) #address_comp2.begin.to_i == 0
+            col_range = str2num(address_comp2.begin)..str2num(address_comp2.end)
+            col_range==(0..0) ? nil : col_range
+          else
+            address_comp2.begin..address_comp2.end
+          end          
+        end
+      rescue
+        raise AddressInvalid, "address (#{address.inspect}) format not correct"
+      end
+      if format==:r1c1
+        r1c1_string(@@row_letter,rows,:min) + r1c1_string(@@col_letter,columns,:min) + ":" + 
+        r1c1_string(@@row_letter,rows,:max) + r1c1_string(@@col_letter,columns,:max)
+      elsif format==:int_range
+        [rows,columns]
+      else
+        raise NotImplementedREOError, "not implemented"
+      end
+    end  
+
+    # @private
+    def self.r1c1_string(letter,int_range,type)
+      return "" if int_range.nil? || int_range.begin.nil?
+      parameter = type == :min ? int_range.begin : int_range.end
+      is_relative = parameter.is_a?(Array)
+      parameter = parameter.first if is_relative
+      letter + (is_relative ? "(" : "") + parameter.to_s + (is_relative ? ")" : "")       
+    end 
+
+    # @private
+    def self.analyze(comp,format)
+      row_comp, col_comp = if format==:a1 
+        [comp.gsub(/[A-Z]/,''), comp.gsub(/[0-9]/,'')]
+      else
+        a,b = comp.split(@@row_letter)
+        c,d = b.split(@@col_letter)
+        b.nil? ? ["",b] : (d.nil? ? [c,""] : [c,d])  
+      end
+      def self.s2n(s)
+        s!="" ? (s[0] == "[" ? [s.gsub(/\[|\]/,'').to_i] : (s.to_i!=0 ? s.to_i : s)) : nil
+      end
+      [s2n(row_comp), s2n(col_comp)]
+    end
+
+
+    # @private
+    def self.str2num(str)
+      str.tr("A-Z","0-9A-P").to_i(26) + (26**str.size-1)/25
+    end
+
+  end
+
+end

data/lib/robust_excel_ole/excel.rb

@@ -135,7 +135,7 @@ module RobustExcelOle
       self
     end
 
-    private
+  private
 
     # returns a Win32OLE object that represents a Excel instance to which Excel connects
     # connects to the first opened Excel instance
@@ -162,23 +162,32 @@ module RobustExcelOle
       result
     end
 
-    public
-
     # retain the saved status of all workbooks
+    # @private
     def retain_saved_workbooks
-      saved = []
-      @ole_excel.Workbooks.each { |w| saved << w.Saved }
+      saved_stati = @ole_excel.Workbooks.map { |w| w.Saved }
       begin
         yield self
       ensure
-        i = 0
-        @ole_excel.Workbooks.each do |w|
-          w.Saved = saved[i] if saved[i]
-          i += 1
+        @ole_excel.Workbooks.zip(saved_stati) { |w,s| w.Saved = s }
+      end
+    end
+
+    # @private
+    def ole_workbooks
+      ole_workbooks = begin
+        @ole_excel.Workbooks
+      rescue WIN32OLERuntimeError => msg
+        if msg.message =~ /failed to get Dispatch Interface/
+          raise ExcelDamaged, 'Excel instance not alive or damaged'
+        else
+          raise ExcelREOError, 'workbooks could not be determined'
         end
       end
     end
 
+  public
+
     def self.contains_unsaved_workbooks?
       !Excel.current.unsaved_workbooks.empty?
     end
@@ -198,8 +207,8 @@ module RobustExcelOle
     # @option options [Symbol] :if_unsaved :raise, :save, :forget, :alert, Proc
     #  :if_unsaved    if unsaved workbooks are open in an Excel instance
     #                      :raise (default) -> raises an exception
-    #                      :save            -> saves the workbooks before closing
     #                      :forget          -> closes the Excel instance without saving the workbooks
+    #                      :save            -> saves the workbooks before closing
     #                      :alert           -> let Excel do it
     def close_workbooks(options = { :if_unsaved => :raise })
       return unless alive?
@@ -210,7 +219,9 @@ module RobustExcelOle
         when Proc
           options[:if_unsaved].call(self, unsaved_workbooks)
         when :raise
-          raise UnsavedWorkbooks, 'Excel contains unsaved workbooks'
+          raise UnsavedWorkbooks, "Excel contains unsaved workbooks" +
+          "\nHint: Use option :if_unsaved with values :forget and :save to close the 
+           Excel instance without or with saving the unsaved workbooks before, respectively"
         when :alert
           # nothing
         when :forget
@@ -218,7 +229,8 @@ module RobustExcelOle
         when :save
           unsaved_workbooks.each { |m| m.Save }
         else
-          raise OptionInvalid, ":if_unsaved: invalid option: #{options[:if_unsaved].inspect}"
+          raise OptionInvalid, ":if_unsaved: invalid option: #{options[:if_unsaved].inspect}" +
+          "\nHint: Valid values are :raise, :forget, :save and :alert"
         end
       end
       begin
@@ -501,27 +513,9 @@ module RobustExcelOle
       self.Workbooks.each { |w| trace "#{w.Name} #{w}" }
     end
 
-    # generates, saves, and closes empty workbook
     # @private
-    def generate_workbook file_name
-      raise FileNameNotGiven, 'filename is nil' if file_name.nil?
-
-      self.Workbooks.Add
-      empty_workbook = self.Workbooks.Item(self.Workbooks.Count)
-      filename = General.absolute_path(file_name).tr('/','\\')
-      unless File.exist?(filename)
-        begin
-          empty_workbook.SaveAs(filename)
-        rescue WIN32OLERuntimeError => msg
-          # if msg.message =~ /SaveAs/ and msg.message =~ /Workbook/ then
-          raise FileNotFound, "could not save workbook with filename #{file_name.inspect}"
-          # else
-          #  # todo some time: find out when this occurs :
-          #  raise UnexpectedREOError, "unknown WIN32OLERuntimeError with filename #{file_name.inspect}: \n#{msg.message}"
-          # end
-        end
-      end
-      empty_workbook
+    def generate_workbook file_name  # :deprecated: #
+      workbook_class.open(file_name, :if_absent => :create, :force => {:excel => self})
     end
 
     # sets DisplayAlerts in a block
@@ -559,16 +553,36 @@ module RobustExcelOle
       @calculation = calculation_mode
       calc_mode_changable = @ole_excel.Workbooks.Count > 0 && @ole_excel.Calculation.is_a?(Integer)
       if calc_mode_changable
-        #if calculation_mode == :manual
+        retain_saved_workbooks do
+          begin
+            best_wb_to_make_visible = @ole_excel.Workbooks.sort_by {|wb|
+              score =
+                (wb.Saved    ? 0 : 40) +  # an unsaved workbooks is most likely the main workbook
+                (wb.ReadOnly ? 0 : 20) +  # the main wb is usually writable
+                case wb.Name.split(".").last.downcase
+                  when "xlsm" then 10  # the main workbook is more likely to have macros
+                  when "xls"  then  8
+                  when "xlsx" then  4
+                  when "xlam" then -2  # libraries are not normally the main workbook
+                  else 0
+                end
+              score
+            }.last
+            best_wb_to_make_visible.Windows(1).Visible = true
+          rescue => e
+            trace "error setting calculation=#{calculation_mode} msg: " + e.message
+            trace e.backtrace
+            # continue on errors here, failing would usually disrupt too much
+          end
           saved = []
-          (1..@ole_excel.Workbooks.Count).each { |i| saved << @ole_excel.Workbooks(i).Saved }
-        #end
-        @ole_excel.CalculateBeforeSave = false
-        @ole_excel.Calculation =
-          calculation_mode == :automatic ? XlCalculationAutomatic : XlCalculationManual
-        #if calculation_mode == :manual
-          (1..@ole_excel.Workbooks.Count).each { |i| @ole_excel.Workbooks(i).Saved = true if saved[i - 1] }
-        #end
+          @ole_excel.Workbooks.each { |w| saved << w.Saved }
+          @ole_excel.CalculateBeforeSave = false
+          @ole_excel.Calculation =
+            calculation_mode == :automatic ? XlCalculationAutomatic : XlCalculationManual
+          saved = []
+          @ole_excel.Workbooks.each { |w| saved << w.Saved }
+        end
+        #(1..@ole_excel.Workbooks.Count).each { |i| @ole_excel.Workbooks(i).Saved = true if saved[i - 1] }
       end
     end
 
@@ -603,21 +617,36 @@ module RobustExcelOle
 
     def set_options(options)
       for_this_instance(options)
-    end
+    end    
 
     # set options in all workbooks
     def for_all_workbooks(options)
-      ole_workbooks = begin
-        @ole_excel.Workbooks
-      rescue WIN32OLERuntimeError => msg
-        if msg.message =~ /failed to get Dispatch Interface/
-          raise ExcelDamaged, 'Excel instance not alive or damaged'
-        else
-          raise ExcelREOError, 'workbooks could not be determined'
-        end
+      each_workbook(options)
+    end
+
+    def workbooks
+      #ole_workbooks.map {|ole_workbook| ole_workbook.to_reo }
+      ole_workbooks.map {|ole_workbook| workbook_class.new(ole_workbook) }
+    end
+
+    # traverses over all workbooks and sets options if provided
+    def each_workbook(opts = { })
+      ole_workbooks.each do |ow|
+        wb = workbook_class.new(ow, opts)
+        block_given? ? (yield wb) : wb
+        #if block_given? 
+        #  yield workbook_class.new(ow, opts)
+        #else
+        #  workbook_class.new(ow, opts)
+        #end
       end
-      ole_workbooks.each do |ole_workbook|
-        workbook_class.open(ole_workbook).for_this_workbook(options)
+    end
+
+    def each_workbook_with_index(opts = { }, offset = 0)
+      i = offset
+      ole_workbooks.each do |ow| 
+        yield workbook_class.new(ow, opts), i 
+        i += 1
       end
     end
 
@@ -678,7 +707,6 @@ module RobustExcelOle
       if name.to_s[0,1] =~ /[A-Z]/
         begin
           raise ObjectNotAlive, 'method missing: Excel not alive' unless alive?
-
           @ole_excel.send(name, *args)
         rescue WIN32OLERuntimeError => msg
           if msg.message =~ /unknown property or method/