robust_excel_ole 1.9 → 1.10

data/lib/robust_excel_ole/range_owners.rb

@@ -21,15 +21,30 @@ module RobustExcelOle
         return opts[:default] unless opts[:default] == :__not_provided
         raise
       end
+      ole_range = name_obj.RefersToRange
       value = begin
-        name_obj.RefersToRange.Value
+        #name_obj.RefersToRange.Value
+        if RUBY_PLATFORM !~ /java/         
+          ole_range.Value
+        else
+          values = RobustExcelOle::Range.new(ole_range).v
+          (values.size==1 && values.first.size==1) ? values.first.first : values
+        end
       rescue WIN32OLERuntimeError
         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)
         end
         begin
-          sheet.Evaluate(name_obj.Name).Value
+          #sheet.Evaluate(name_obj.Name).Value
+          # does it result in a range?
+          ole_range = sheet.Evaluate(name_obj.Name)
+          if RUBY_PLATFORM !~ /java/
+            ole_range.Value
+          else
+            values = RobustExcelOle::Range.new(ole_range).v
+            (values.size==1 && values.first.size==1) ? values.first.first : values
+          end
         rescue # WIN32OLERuntimeError
           return opts[:default] unless opts[:default] == :__not_provided
           raise RangeNotEvaluatable, "cannot evaluate range named #{name.inspect} in #{self}"
@@ -49,12 +64,30 @@ module RobustExcelOle
     # @param [FixNum]  color the color when setting a value
     # @param [Hash]    opts :color [FixNum]  the color when setting the contents
     def set_namevalue_glob(name, value, opts = { :color => 0 })
-      cell = name_object(name).RefersToRange
-      cell.Interior.ColorIndex = opts[:color]
-      workbook.modified_cells << cell if workbook # unless cell_modified?(cell)
-      cell.Value = value
-    rescue WIN32OLERuntimeError
-      raise RangeNotEvaluatable, "cannot assign value to range named #{name.inspect} in #{self.inspect}"
+      begin
+        name_obj = begin
+          name_object(name)
+        rescue NameNotFound => msg
+          raise
+        end
+        ole_range = name_object(name).RefersToRange
+        ole_range.Interior.ColorIndex = opts[:color]
+        workbook.modified_cells << ole_range if workbook # unless cell_modified?(cell)
+        if RUBY_PLATFORM !~ /java/
+          ole_range.Value = value
+        else
+          address_r1c1 = ole_range.AddressLocal(true,true,XlR1C1)
+          row, col = Address.int_range(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
+        raise RangeNotEvaluatable, "cannot assign value to range named #{name.inspect} in #{self.inspect}"
+      end
     end
 
     # returns the contents of a range with a locally defined name
@@ -68,14 +101,20 @@ module RobustExcelOle
     def namevalue(name, opts = { :default => :__not_provided })
       return namevalue_glob(name, opts) if self.is_a?(Workbook)
       begin
-        range = self.Range(name)
-      rescue WIN32OLERuntimeError
+        ole_range = self.Range(name)
+      rescue # WIN32OLERuntimeError
         return opts[:default] unless opts[:default] == :__not_provided
         raise NameNotFound, "name #{name.inspect} not in #{self.inspect}"
       end
       begin
-        value = range.Value
-      rescue  WIN32OLERuntimeError
+        #value = ole_range.Value
+        value = if RUBY_PLATFORM !~ /java/
+          ole_range.Value
+        else
+          values = RobustExcelOle::Range.new(ole_range).v
+          (values.size==1 && values.first.size==1) ? values.first.first : values
+        end
+      rescue  #WIN32OLERuntimeError
         return opts[:default] unless opts[:default] == :__not_provided
         raise RangeNotEvaluatable, "cannot determine value of range named #{name.inspect} in #{self.inspect}"
       end
@@ -94,15 +133,27 @@ module RobustExcelOle
     def set_namevalue(name, value, opts = { :color => 0 })
       begin
         return set_namevalue_glob(name, value, opts) if self.is_a?(Workbook)
-        range = self.Range(name)
-      rescue WIN32OLERuntimeError
+        ole_range = self.Range(name)
+      rescue # WIN32OLERuntimeError
         raise NameNotFound, "name #{name.inspect} not in #{self.inspect}"
       end
       begin
-        range.Interior.ColorIndex = opts[:color]
-        workbook.modified_cells << range if workbook # unless cell_modified?(range)
-        range.Value = value
-      rescue  WIN32OLERuntimeError
+        ole_range.Interior.ColorIndex = opts[:color]
+        workbook.modified_cells << ole_range if workbook # unless cell_modified?(range)
+        #range.Value = value
+        if RUBY_PLATFORM !~ /java/
+          ole_range.Value = value
+        else
+          address_r1c1 = ole_range.AddressLocal(true,true,XlR1C1)
+          row, col = Address.int_range(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
         raise RangeNotEvaluatable, "cannot assign value to range named #{name.inspect} in #{self.inspect}"
       end
     end
@@ -134,30 +185,26 @@ module RobustExcelOle
     def range(name_or_address, address2 = :__not_provided)
       begin
         if address2 == :__not_provided
-          range = begin
-            RobustExcelOle::Range.new(name_object(name_or_address).RefersToRange) 
-          rescue NameNotFound
-            nil
+          range = if name_or_address.is_a?(String)
+            begin
+              RobustExcelOle::Range.new(name_object(name_or_address).RefersToRange) 
+            rescue NameNotFound
+              nil
+            end
           end
         end
         if self.is_a?(Worksheet) && (range.nil? || (address2 != :__not_provided))
           address = name_or_address
           address = [name_or_address,address2] unless address2 == :__not_provided
-          self.Names.Add('Name' => '__dummy001', 'RefersToR1C1' => '=' + Address.r1c1(address))
+          #self.Names.Add('Name' => '__dummy001', 'RefersToR1C1' => '=' + Address.r1c1(address))
+          #not_given = WIN32OLE_VARIANT.new(nil, WIN32OLE::VARIANT::VT_NULL)
+          #self.Names.Add('__dummy001',not_given,true,not_given,not_given,not_given,not_given,not_given,not_given,'=' + Address.r1c1(address))          
+          self.Names.Add('__dummy001',nil,true,nil,nil,nil,nil,nil,nil,'=' + Address.r1c1(address))          
           range = RobustExcelOle::Range.new(name_object('__dummy001').RefersToRange)
           self.Names.Item('__dummy001').Delete
-          range          
-          # variant via rows, columns:
-          #rows, columns = Address.int_range(address)
-          #ole_range = if rows.nil?
-          #  self.Range(self.Columns(columns.min), self.Columns(columns.max))
-          #elsif columns.nil?
-          #  self.Range(self.Rows(rows.min), self.Rows(rows.max))
-          #else
-          #  self.Range(self.Cells(rows.min, columns.min), self.Cells(rows.max, columns.max))
-          #end
-          ##range = ole_range.to_reo
-          #range = Range.new(ole_range)
+          workbook = self.is_a?(Workbook) ? self : self.workbook
+          workbook.save
+          range                    
         end
       rescue WIN32OLERuntimeError
         address2_string = address2.nil? ? "" : ", #{address2.inspect}"
@@ -176,8 +223,11 @@ module RobustExcelOle
     def add_name(name, addr, addr_deprecated = :__not_provided)
       addr = [addr,addr_deprecated] unless addr_deprecated == :__not_provided
       begin
-        self.Names.Add('Name' => name, 'RefersToR1C1' => '=' + Address.r1c1(addr))
-      rescue WIN32OLERuntimeError => msg
+        #self.Names.Add('Name' => name, 'RefersToR1C1' => '=' + Address.r1c1(addr))
+        #not_given = WIN32OLE_VARIANT.new(nil, WIN32OLE::VARIANT::VT_NULL)
+        #self.Names.Add(name, not_given, true, not_given, not_given, not_given, not_given, not_given, not_given, '=' + Address.r1c1(addr))
+        self.Names.Add(name, nil, true, nil, nil, nil, nil, nil, nil, '=' + Address.r1c1(addr))
+      rescue # WIN32OLERuntimeError => msg
         raise RangeNotEvaluatable, "cannot add name #{name.inspect} to range #{addr.inspect}"
       end
       name
@@ -223,10 +273,10 @@ module RobustExcelOle
 
     def name_object(name)
       self.Names.Item(name)
-    rescue WIN32OLERuntimeError
+    rescue #WIN32OLERuntimeError
       begin
         self.Parent.Names.Item(name)
-      rescue WIN32OLERuntimeError
+      rescue #WIN32OLERuntimeError
         raise RobustExcelOle::NameNotFound, "name #{name.inspect} not in #{self.inspect}"
       end
     end

data/lib/robust_excel_ole/reo_common.rb

@@ -18,6 +18,10 @@ end
 
 module RobustExcelOle
 
+  # @private
+  class VBAMethodMissingError < RuntimeError 
+  end
+
   # @private
   class REOError < RuntimeError                    
   end

data/lib/robust_excel_ole/version.rb

@@ -1,3 +1,3 @@
 module RobustExcelOle
-  VERSION = "1.9"
+  VERSION = "1.10"
 end

data/lib/robust_excel_ole/workbook.rb

@@ -166,7 +166,7 @@ module RobustExcelOle
       bookstore.store(self)
       @modified_cells = []
       @workbook = @excel.workbook = self
-      r1c1_letters = @ole_workbook.Worksheets.Item(1).Cells.Item(1,1).Address('ReferenceStyle' => XlR1C1).gsub(/[0-9]/,'')
+      r1c1_letters = @ole_workbook.Worksheets.Item(1).Cells.Item(1,1).Address(true,true,XlR1C1).gsub(/[0-9]/,'') #('ReferenceStyle' => XlR1C1).gsub(/[0-9]/,'')
       address_class.new(r1c1_letters)
       if block
         begin
@@ -255,7 +255,7 @@ module RobustExcelOle
 
 
     # @private
-    def ensure_workbook(filename, options)    
+    def ensure_workbook(filename, options)  
       filename = @stored_filename ? @stored_filename : filename
       raise(FileNameNotGiven, 'filename is nil') if filename.nil?
       if File.directory?(filename)
@@ -282,7 +282,7 @@ module RobustExcelOle
         abs_filename = General.absolute_path(filename).tr('/','\\')
         begin
           empty_ole_workbook.SaveAs(abs_filename)
-        rescue WIN32OLERuntimeError => msg
+        rescue # WIN32OLERuntimeError => msg
           raise FileNotFound, "could not save workbook with filename #{filename.inspect}"
         end
       else
@@ -387,8 +387,10 @@ module RobustExcelOle
           end
           begin
             with_workaround_linked_workbooks_excel2007(options) do
-              workbooks.Open(abs_filename, { 'ReadOnly' => options[:read_only] })
-              #                           'UpdateLinks' => updatelinks_vba(options[:update_links]) })
+              # 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 => msg
             # for Excel2007: for option :if_unsaved => :alert and user cancels: this error appears?
@@ -783,41 +785,6 @@ module RobustExcelOle
       end
     end
 
-    # copies a sheet to another position
-    # default: copied sheet is appended
-    # @param [Worksheet] sheet a sheet that shall be copied
-    # @param [Hash]  opts  the options
-    # @option opts [Symbol] :as     new name of the copied sheet
-    # @option opts [Symbol] :before a sheet before which the sheet shall be inserted
-    # @option opts [Symbol] :after  a sheet after which the sheet shall be inserted
-    # @raise  NameAlreadyExists if the sheet name already exists
-    # @return [Worksheet] the copied sheet
-    def copy_sheet(sheet, opts = { })
-      new_sheet_name = opts.delete(:as)
-      after_or_before, base_sheet = opts.to_a.first || [:after, last_sheet]
-      sheet.Copy({ after_or_before.to_s => base_sheet.ole_worksheet })
-      new_sheet = worksheet_class.new(@excel.Activesheet)
-      new_sheet.name = new_sheet_name if new_sheet_name
-      new_sheet
-    end
-
-    # adds an empty sheet
-    # default: empty sheet is appended
-    # @param [Hash]  opts  the options
-    # @option opts [Symbol] :as     new name of the copied added sheet
-    # @option opts [Symbol] :before a sheet before which the sheet shall be inserted
-    # @option opts [Symbol] :after  a sheet after which the sheet shall be inserted
-    # @raise  NameAlreadyExists if the sheet name already exists
-    # @return [Worksheet] the added sheet
-    def add_empty_sheet(opts = { })
-      new_sheet_name = opts.delete(:as)
-      after_or_before, base_sheet = opts.to_a.first || [:after, last_sheet]
-      @ole_workbook.Worksheets.Add({ after_or_before.to_s => base_sheet.ole_worksheet })
-      new_sheet = worksheet_class.new(@excel.Activesheet)
-      new_sheet.name = new_sheet_name if new_sheet_name
-      new_sheet
-    end
-
     # copies a sheet to another position if a sheet is given, or adds an empty sheet
     # default: copied or empty sheet is appended, i.e. added behind the last sheet
     # @param [Worksheet] sheet a sheet that shall be copied (optional)
@@ -831,7 +798,49 @@ module RobustExcelOle
         opts = sheet
         sheet = nil
       end
-      sheet ? copy_sheet(sheet, opts) : add_empty_sheet(opts)
+      new_sheet_name = opts.delete(:as)
+      last_sheet_local = last_sheet
+      after_or_before, base_sheet = opts.to_a.first || [:after, last_sheet_local]
+      begin
+        if RUBY_PLATFORM !~ /java/
+          if sheet 
+            sheet.Copy({ after_or_before.to_s => base_sheet.ole_worksheet })
+          else
+            @ole_workbook.Worksheets.Add({ after_or_before.to_s => base_sheet.ole_worksheet })
+          end
+        else
+          # workaround for jruby      
+          if after_or_before == :before 
+            if sheet 
+              sheet.Copy(base_sheet.ole_worksheet)
+            else
+              ole_workbook.Worksheets.Add(base_sheet.ole_worksheet)
+            end
+          else
+            #not_given = WIN32OLE_VARIANT.new(nil, WIN32OLE::VARIANT::VT_NULL)
+            #ole_workbook.Worksheets.Add(not_given,base_sheet.ole_worksheet)          
+            if base_sheet.name != last_sheet_local.name
+              if sheet
+                sheet.Copy(base_sheet.Next)
+              else
+                ole_workbook.Worksheets.Add(base_sheet.Next)
+              end
+            else
+              if sheet
+                sheet.Copy(base_sheet.ole_worksheet)  
+              else
+                ole_workbook.Worksheets.Add(base_sheet.ole_worksheet) 
+              end
+              base_sheet.Move(ole_workbook.Worksheets.Item(ole_workbook.Worksheets.Count-1))
+            end
+          end
+        end
+      rescue WIN32OLERuntimeError 
+        raise WorksheetREOError, "given sheet #{sheet.inspect} not found"
+      end
+      new_sheet = worksheet_class.new(@excel.Activesheet)
+      new_sheet.name = new_sheet_name if new_sheet_name
+      new_sheet
     end
 
     # for compatibility to older versions
@@ -839,6 +848,11 @@ module RobustExcelOle
       add_or_copy_sheet(sheet, opts)
     end
 
+    # for compatibility to older versions
+    def copy_sheet(sheet, opts = { })
+      add_or_copy_sheet(sheet, opts)
+    end
+
     def last_sheet
       worksheet_class.new(@ole_workbook.Worksheets.Item(@ole_workbook.Worksheets.Count))
     end

data/spec/bookstore_spec.rb

@@ -87,6 +87,47 @@ describe Bookstore do
     end
   end
 
+  describe "excel" do
+
+    context "with one open book" do
+      
+      before do
+        @book = Workbook.open(@simple_file)
+        @bookstore.store(@book)
+      end
+
+      after do
+        @book.close rescue nil
+      end
+
+      it "should return the excel" do                
+        @bookstore.excel.should == @book.excel
+      end
+    end
+
+    context "with one closed book" do
+      
+      before do
+        @book = Workbook.open(@simple_file)
+        @bookstore.store(@book)
+        @book.close
+      end
+
+      it "should return the excel of the closed book" do        
+        @bookstore.excel.should == @book.excel
+      end
+    end
+
+    context "with no book" do
+      
+      it "should return nil" do        
+        @bookstore.excel.should == nil
+      end
+    end
+
+
+  end
+
 
   describe "fetch" do
     
@@ -472,7 +513,8 @@ describe Bookstore do
         book1 = Workbook.open(@simple_file, :force_excel => @bookstore.hidden_excel)
         book1.excel.should === h_excel1
         book1.excel.should_not === @book.excel
-        Excel.close_all    
+        #Excel.close_all    
+        Excel.kill_all
         h_excel2 = @bookstore.hidden_excel
         h_excel2.should_not == @book.excel
         h_excel2.should_not == book1.excel

data/spec/excel_spec.rb

@@ -35,7 +35,8 @@ module RobustExcelOle
       before do
         @ole_excel1 = WIN32OLE.new('Excel.Application')
         @ole_excel2 = WIN32OLE.new('Excel.Application')
-        ole_workbook1 = @ole_excel1.Workbooks.Open(@another_simple_file, { 'ReadOnly' => false })
+        #ole_workbook1 = @ole_excel1.Workbooks.Open(@another_simple_file, { 'ReadOnly' => false })
+        ole_workbook1 = @ole_excel1.Workbooks.Open(@another_simple_file, nil, false)
         ole_workbook1.Names.Item("firstcell").RefersToRange.Value = "foo"
       end
 
@@ -1720,7 +1721,7 @@ module RobustExcelOle
       end
 
       it "should set options in the Excel instance" do
-        @excel.for_this_instance(:displayalerts => true, :visible => true, :screenupdating => true, :calculaiton => :manual)
+        @excel.for_this_instance(:displayalerts => true, :visible => true, :screenupdating => true, :calculation => :manual)
         @excel.DisplayAlerts.should be true
         @excel.Visible.should be true
         @excel.ScreenUpdating.should be true

data/spec/helpers/key_sender.rb

@@ -1,5 +1,6 @@
 
 require 'win32ole'
+#require 'jruby-win32ole'
 
 # @private
 class KeySender