robust_excel_ole 1.25 → 1.30

data/lib/robust_excel_ole/list_object.rb

@@ -16,6 +16,10 @@ module RobustExcelOle
 
     alias ole_object ole_table
 
+    using FindAllIndicesRefinement
+    using StringRefinement
+    using ToReoRefinement
+   
     # constructs a list object (or table).
     # @param [Variable] worksheet_or_listobject      a worksheet or a list object
     # @param [Variable] table_name_or_number         a table name or table number
@@ -124,7 +128,7 @@ module RobustExcelOle
           rescue WIN32OLERuntimeError
             raise TableError, "could not delete values"
           end
-        end
+        end        
 
         def method_missing(name, *args)
           name_str = name.to_s
@@ -351,7 +355,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

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.25"
+  VERSION = "1.30"
 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
@@ -235,13 +235,12 @@ module RobustExcelOle
       raise ExcelREOError, "Excel is not alive" unless @excel && @excel.alive?
     end
 
-
     # @private    
     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,6 +253,8 @@ module RobustExcelOle
       if @ole_workbook && alive?
         set_was_open options, true
         manage_blocking_or_unsaved_workbook(filename,options)
+        if @ole_workbook.ReadOnly != options[:read_only]
+        end
         open_or_create_workbook(filename,options) if @ole_workbook.ReadOnly != options[:read_only]
       else
         if (excel_option.nil? || excel_option == :current) &&  
@@ -270,7 +271,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 +327,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
@@ -557,11 +557,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 +593,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 +910,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 +1032,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 +1050,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

data/lib/robust_excel_ole/worksheet.rb

@@ -80,7 +80,7 @@ module RobustExcelOle
       else
         name = p1
         begin
-          namevalue_glob(name)
+          namevalue_global(name)
         rescue REOError
           namevalue(name)
         end
@@ -96,10 +96,10 @@ module RobustExcelOle
       else
         name, value = p1, p2
         begin
-          set_namevalue_glob(name, value)
+          set_namevalue_global(name, value)
         rescue REOError
           begin
-            workbook.set_namevalue_glob(name, value)
+            workbook.set_namevalue_global(name, value)
           rescue REOError
             set_namevalue(name, value)
           end
@@ -107,6 +107,71 @@ 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 })
+      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
+        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
+
     # value of a cell, if row and column are given
     # @params row and column
     # @returns value of the cell
@@ -248,11 +313,14 @@ module RobustExcelOle
       false
     end
 
+    using ParentRefinement
+    using StringRefinement
+
     # @private
     def self.workbook_class  
       @workbook_class ||= begin
         module_name = self.parent_name
-        "#{module_name}::Workbook".constantize
+        "#{module_name}::Workbook".constantize        
       rescue NameError => e
         Workbook
       end

data/spec/base_spec.rb

@@ -36,19 +36,6 @@ module RobustExcelOle
       rm_tmp(@dir)
     end
 
-    describe "trace" do
-
-      it "should put some number" do
-        a = 4
-        Base::trace "some text #{a}"
-      end
-
-      it "should put another text" do
-        b = Workbook.open(@simple_file)
-        Base::trace "book: #{b}"
-      end
-    end
-
     describe "own_methods" do
 
       before do
@@ -57,8 +44,8 @@ module RobustExcelOle
           ["Activate", "ActiveSheet", "Application", "Close", "FullName", "HasPassword", "Name", "Names", 
             "Password", "Protect", "ProtectSharing", "ProtectStructure", "Protect", "ReadOnly", "Save", 
             "SaveAs", "Saved", "Sheets", "Unprotect"]
-        @book_methods = ["focus", "add_sheet", "alive?", "close", "filename", "namevalue", "ole_object", 
-                         "ole_workbook", "reopen", "save", "save_as", "saved", "set_namevalue"]
+        @book_methods = ["focus", "add_sheet", "alive?", "close", "filename", "ole_object", 
+                         "ole_workbook", "reopen", "save", "save_as", "saved"]
         @ole_excel_methods = 
           ["ActiveCell", "ActiveSheet", "ActiveWorkbook", "Application",  "Calculate", "Cells", "Columns",
             "DisplayAlerts", "Evaluate", "Hwnd", "Name", "Names", "Quit", "Range", "Ready", "Save", 
@@ -82,6 +69,21 @@ module RobustExcelOle
 
     end
 
+    describe "trace" do
+
+      it "should put some number" do
+        a = 4
+        Base::trace "some text #{a}"
+      end
+
+      it "should put another text" do
+        b = Workbook.open(@simple_file)
+        Base::trace "book: #{b}"
+      end
+    end
+
+    
+
     describe "misc" do
 
       it "should" do