robust_excel_ole 0.3.4 → 0.3.5

data/lib/robust_excel_ole/{book_store.rb → bookstore.rb}

@@ -3,7 +3,7 @@
 
 module RobustExcelOle
 
-  class BookStore
+  class Bookstore
 
     def initialize
       @filename2books = Hash.new {|hash, key| hash[key] = [] }
@@ -99,7 +99,7 @@ module RobustExcelOle
 
   end
 
-  class BookStoreError < WIN32OLERuntimeError # :nodoc: #
+  class BookstoreError < WIN32OLERuntimeError # :nodoc: #
   end
  
 end

data/lib/robust_excel_ole/excel.rb

@@ -6,16 +6,6 @@ module RobustExcelOle
 
     @@hwnd2excel = {}
 
-    # closes all Excel instances
-    def self.close_all
-      while current_excel do
-        close_one_excel
-        GC.start
-        sleep 0.3
-        #free_all_ole_objects
-      end
-    end
-
     # creates a new Excel instance
     def self.create
       new(:reuse => false)
@@ -55,7 +45,7 @@ module RobustExcelOle
         result = stored
       else
         result = super(options)
-        result.instance_variable_set(:@excel, excel)
+        result.instance_variable_set(:@this_excel, excel)
         WIN32OLE.const_load(excel, RobustExcelOle) unless RobustExcelOle.const_defined?(:CONSTANTS)
         @@hwnd2excel[hwnd] = result        
       end
@@ -63,6 +53,107 @@ module RobustExcelOle
     end
 
     def initialize(options= {}) # :nodoc: #
+      @excel = self
+    end
+
+    # closes all Excel instances
+    # options:
+    #  :if_unsaved    if unsaved workbooks are open in an Excel instance
+    #                      :raise (default) -> raise an exception       
+    #                      :save            -> save the workbooks before closing
+    #                      :forget          -> close the excel instance without saving the workbooks 
+    #                      :alert           -> give control to Excel
+    #  :hard          kill the Excel instances hard (default: false) 
+    def self.close_all(options={})
+      options = {
+        :if_unsaved => :raise,
+        :hard => false
+      }.merge(options)
+      while current_excel do
+        #current_excel.close(options)
+        close_one_excel
+        GC.start
+        sleep 0.3
+        # free_all_ole_objects if options[:hard] ???
+      end
+    end
+
+    # close the Excel
+    #  :if_unsaved    if unsaved workbooks are open in an Excel instance
+    #                      :raise (default) -> raise an exception       
+    #                      :save            -> save the workbooks before closing
+    #                      :forget          -> close the excel instance without saving the workbooks 
+    #                      :alert           -> give control to Excel
+    #  :hard          kill the Excel instance hard (default: false) 
+    def close(options = {})
+      options = {
+        :if_unsaved => :raise,
+        :hard => false
+      }.merge(options)
+      unsaved_books = self.unsaved_workbooks
+      unless unsaved_books.empty? 
+        case options[:if_unsaved]
+        when :raise
+          raise ExcelErrorClose, "Excel contains unsaved workbooks"
+        when :save
+          unsaved_workbooks.each do |workbook|
+            workbook.Save
+          end
+          close_excel(:hard => options[:hard])
+        when :forget
+          close_excel(:hard => options[:hard])
+        when :alert
+          with_displayalerts true do
+            unsaved_workbooks.each do |workbook|
+              workbook.Save
+            end
+            close_excel(:hard => options[:hard])
+          end
+        else
+          raise ExcelErrorClose, ":if_unsaved: invalid option: #{options[:if_unsaved]}"
+        end
+      else
+        close_excel(:hard => options[:hard])
+      end
+      raise ExcelUserCanceled, "close: canceled by user" if options[:if_unsaved] == :alert && self.unsaved_workbooks
+    end
+
+  private
+
+    def close_excel(options)
+      excel = @this_excel
+      excel.Workbooks.Close
+      excel_hwnd = excel.HWnd
+      excel.Quit
+      weak_excel_ref = WeakRef.new(excel)
+      excel = nil
+      GC.start
+      sleep 0.2
+      if weak_excel_ref.weakref_alive? then
+        #if WIN32OLE.ole_reference_count(weak_xlapp) > 0
+        begin
+          weak_excel_ref.ole_free
+          puts "successfully ole_freed #{weak_excel_ref}"
+        rescue
+          puts "could not do ole_free on #{weak_excel_ref}"
+        end
+      end
+      hwnd2excel(excel_hwnd).die rescue nil
+      #@@hwnd2excel[excel_hwnd] = nil
+      #Excel.free_all_ole_objects
+      if options[:hard] then
+        process_id = Win32API.new("user32", "GetWindowThreadProcessId", ["I","P"], "I")
+        pid_puffer = " " * 32
+        process_id.call(excel_hwnd, pid_puffer)
+        pid = pid_puffer.unpack("L")[0]
+        Process.kill("KILL", pid)    
+      end
+    end
+
+  public
+
+    def excel
+      self
     end
 
     # generate, save and close an empty workbook
@@ -100,51 +191,86 @@ module RobustExcelOle
 
     # returns true, if the Excel instances responds to VVA methods, false otherwise
     def alive?
-      @excel.Name
+      @this_excel.Name
       true
     rescue
-      puts $!.message
+      #puts $!.message
       false
     end
 
+    def print_workbooks
+      self.Workbooks.each {|w| puts w.Name}
+    end
+
+    def unsaved_workbooks
+      result = []
+      begin
+        self.Workbooks.each {|w| result << w unless (w.Saved || w.ReadOnly)}
+      rescue RuntimeError => msg
+        puts "RuntimeError: #{msg.message}" 
+        raise ExcelErrorOpen, "Excel instance not alive or damaged" if msg.message =~ /failed to get Dispatch Interface/
+      end
+      result
+    end
+    # yields different WIN32OLE objects than book.workbook
+    #self.class.extend Enumerable
+    #self.class.map {|w| (not w.Saved)}
+
     # set DisplayAlerts in a block
     def with_displayalerts displayalerts_value
-      old_displayalerts = @excel.DisplayAlerts
-      @excel.DisplayAlerts = displayalerts_value
+      old_displayalerts = @this_excel.DisplayAlerts
+      @this_excel.DisplayAlerts = displayalerts_value
       begin
          yield self
       ensure
-        @excel.DisplayAlerts = old_displayalerts
+        @this_excel.DisplayAlerts = old_displayalerts
       end
     end
 
     # enable DisplayAlerts in the current Excel instance
     def displayalerts= displayalerts_value
-      @excel.DisplayAlerts = displayalerts_value
+      @this_excel.DisplayAlerts = displayalerts_value
     end
 
     # return if in the current Excel instance DisplayAlerts is enabled
     def displayalerts 
-      @excel.DisplayAlerts
+      @this_excel.DisplayAlerts
     end
 
     # make the current Excel instance visible or invisible
     def visible= visible_value
-      @excel.Visible = visible_value
+      @this_excel.Visible = visible_value
     end
 
     # return if the current Excel instance is visible
     def visible 
-      @excel.Visible
+      @this_excel.Visible
     end
 
+    def to_s
+      "#<" + "EXCEL:#{hwnd_xxxx}" + ("#{"not alive" unless self.alive?}") + ">"
+    end
+
+    def inspect
+      self.to_s
+    end
 
   private
 
     # closes one Excel instance
-    def self.close_one_excel  
+    def self.close_one_excel(options={})
       excel = current_excel
       if excel then
+        weak_ole_excel = WeakRef.new(excel)
+        excel = nil
+        close_excel_ole_instance(weak_ole_excel.__getobj__)
+      end
+    end
+
+    def self.close_excel_ole_instance(ole_excel)
+      excel = ole_excel
+      ole_excel = nil
+      begin
         excel.Workbooks.Close
         excel_hwnd = excel.HWnd
         excel.Quit
@@ -165,6 +291,10 @@ module RobustExcelOle
 
         hwnd2excel(excel_hwnd).die rescue nil
         #@@hwnd2excel[excel_hwnd] = nil
+
+      rescue => e
+        puts "Error when closing Excel: " + e.message
+        #puts e.backtrace
       end
 
 
@@ -220,14 +350,13 @@ module RobustExcelOle
 
     # set this Excel instance to nil
     def die 
-      @excel = nil
+      @this_excel = nil
     end
 
-
     def method_missing(name, *args) 
       if name.to_s[0,1] =~ /[A-Z]/ 
         begin
-          @excel.send(name, *args)
+          @this_excel.send(name, *args)
         rescue WIN32OLERuntimeError => msg
           if msg.message =~ /unknown property or method/
             raise VBAMethodMissingError, "unknown VBA property or method #{name}"

data/lib/robust_excel_ole/range.rb

@@ -27,8 +27,8 @@ module RobustExcelOle
     end
 
     def [] index
-      @cells ||= []
-      @cells[index + 1] ||= RobustExcelOle::Cell.new(@range.Cells.Item(index + 1))
+      @cells = []
+      @cells[index + 1] = RobustExcelOle::Cell.new(@range.Cells.Item(index + 1))
     end
 
     def method_missing(id, *args)  # :nodoc: #

data/lib/robust_excel_ole/sheet.rb

@@ -1,16 +1,16 @@
 # -*- coding: utf-8 -*-
 module RobustExcelOle
   class Sheet
-    attr_reader :sheet
+    attr_reader :worksheet
     include Enumerable
 
     def initialize(win32_worksheet)
-      @sheet = win32_worksheet
-      if @sheet.ProtectContents
-        @sheet.Unprotect
+      @worksheet = win32_worksheet
+      if @worksheet.ProtectContents
+        @worksheet.Unprotect
         @end_row = last_row
         @end_column = last_column
-        @sheet.Protect
+        @worksheet.Protect
       else
         @end_row = last_row
         @end_column = last_column
@@ -18,21 +18,44 @@ module RobustExcelOle
     end
 
     def name
-      @sheet.Name
+      @worksheet.Name
     end
 
     def name= (new_name)
-      @sheet.Name = new_name
+      begin
+        @worksheet.Name = new_name
+      rescue WIN32OLERuntimeError => msg
+        if msg.message =~ /800A03EC/ 
+          raise ExcelErrorSheet, "sheet name already exists"
+        else
+          puts "#{msg.message}"
+          raise ExcelErrorSheetUnknown
+        end
+      end
     end
 
-    def [] y, x
-      yx = "#{y+1}_#{x+1}"
-      @cells ||= { }
-      @cells[yx] ||= RobustExcelOle::Cell.new(@sheet.Cells.Item(y+1, x+1))
+    # return the value of a cell, if row and column, or its name are given 
+    def [] p1, p2 = :__not_provided
+      if p2 != :__not_provided  
+        y, x = p1, p2
+        yx = "#{y}_#{x}"
+        @cells = { }
+        @cells[yx] = RobustExcelOle::Cell.new(@worksheet.Cells.Item(y, x))
+      else
+        name = p1
+        nvalue(name)
+      end
     end
 
-    def []= (y, x, value)
-      @sheet.Cells.Item(y+1, x+1).Value = value
+    # set the value of a cell, if row and column, or its name are given
+    def []= (p1, p2, p3 = :__not_provided)
+      if p3 != :__not_provided
+        y, x, value = p1, p2, p3
+        @worksheet.Cells.Item(y, x).Value = value
+      else
+        name, value = p1, p2
+        set_nvalue(name, value)
+      end
     end
 
     def each
@@ -47,7 +70,7 @@ module RobustExcelOle
       offset += 1
       1.upto(@end_row) do |row|
         next if row < offset
-        yield RobustExcelOle::Range.new(@sheet.Range(@sheet.Cells(row, 1), @sheet.Cells(row, @end_column)))
+        yield RobustExcelOle::Range.new(@worksheet.Range(@worksheet.Cells(row, 1), @worksheet.Cells(row, @end_column)))
       end
     end
 
@@ -61,7 +84,7 @@ module RobustExcelOle
       offset += 1
       1.upto(@end_column) do |column|
         next if column < offset
-        yield RobustExcelOle::Range.new(@sheet.Range(@sheet.Cells(1, column), @sheet.Cells(@end_row, column)))
+        yield RobustExcelOle::Range.new(@worksheet.Range(@worksheet.Cells(1, column), @worksheet.Cells(@end_row, column)))
       end
     end
 
@@ -72,49 +95,78 @@ module RobustExcelOle
     end
 
     def row_range(row, range = nil)
-      range ||= 0..@end_column - 1
-      RobustExcelOle::Range.new(@sheet.Range(@sheet.Cells(row + 1, range.min + 1), @sheet.Cells(row + 1, range.max + 1)))
+      range ||= 1..@end_column
+      RobustExcelOle::Range.new(@worksheet.Range(@worksheet.Cells(row , range.min ), @worksheet.Cells(row , range.max )))
     end
 
     def col_range(col, range = nil)
-      range ||= 0..@end_row - 1
-      RobustExcelOle::Range.new(@sheet.Range(@sheet.Cells(range.min + 1, col + 1), @sheet.Cells(range.max + 1, col + 1)))
+      range ||= 1..@end_row
+      RobustExcelOle::Range.new(@worksheet.Range(@worksheet.Cells(range.min , col ), @worksheet.Cells(range.max , col )))
     end
 
-    # returns the contents of a range or cell with given name
-    def nvalue(name)
+    # returns the contents of a range with given name
+    # if no contents could returned, then return default value, if a default value was provided
+    #                                raise an error, otherwise
+    def nvalue(name, opts = {:default => nil})
       begin
         item = self.Names.Item(name)
       rescue WIN32OLERuntimeError
-        raise SheetErrorNValue, "name #{name} not in sheet"  
+        return opts[:default] if opts[:default]
+        raise SheetError, "name #{name} not in sheet"
       end
       begin
-        referstorange = item.RefersToRange
-      rescue WIN32OLERuntimeError
-        raise SheetErrorNValue, "range error in sheet"      
+        value = item.RefersToRange.Value
+      rescue  WIN32OLERuntimeError
+        return opts[:default] if opts[:default]
+        raise SheetError, "RefersToRange of name #{name}"
       end
+      value
+    end
+
+    def set_nvalue(name,value)
       begin
-        value = referstorange.Value
+        item = self.Names.Item(name)
       rescue WIN32OLERuntimeError
-        raise SheetErrorNValue, "value error in sheet" 
+        raise SheetError, "name #{name} not in sheet"
+      end
+      begin
+        item.RefersToRange.Value = value
+      rescue  WIN32OLERuntimeError
+        raise SheetError, "RefersToRange of name #{name}"
+      end
+    end
+
+    # assigns a name to a range (a cell) given by an address
+    def set_name(name,row,column)
+      begin
+        old_name = self[row,column].Name.Name rescue nil
+        if old_name
+          self[row,column].Name.Name = name
+        else
+          address = "Z" + row.to_s + "S" + column.to_s 
+          self.Names.Add("Name" => name, "RefersToR1C1" => "=" + address)
+        end
+      rescue WIN32OLERuntimeError => msg
+        puts "WIN32OLERuntimeError: #{msg.message}"
+        raise SheetError, "cannot add name #{name} to cell with row #{row} and column #{column}"
       end
     end
 
     def method_missing(id, *args)  # :nodoc: #
-      @sheet.send(id, *args)
+      @worksheet.send(id, *args)
     end
 
     private
     def last_row
-      special_last_row = @sheet.UsedRange.SpecialCells(RobustExcelOle::XlLastCell).Row
-      used_last_row = @sheet.UsedRange.Rows.Count
+      special_last_row = @worksheet.UsedRange.SpecialCells(RobustExcelOle::XlLastCell).Row
+      used_last_row = @worksheet.UsedRange.Rows.Count
 
       special_last_row >= used_last_row ? special_last_row : used_last_row
     end
 
     def last_column
-      special_last_column = @sheet.UsedRange.SpecialCells(RobustExcelOle::XlLastCell).Column
-      used_last_column = @sheet.UsedRange.Columns.Count
+      special_last_column = @worksheet.UsedRange.SpecialCells(RobustExcelOle::XlLastCell).Column
+      used_last_column = @worksheet.UsedRange.Columns.Count
 
       special_last_column >= used_last_column ? special_last_column : used_last_column
     end    
@@ -125,7 +177,4 @@ module RobustExcelOle
   class SheetError < RuntimeError    # :nodoc: #
   end
 
-  class SheetErrorNValue < WIN32OLERuntimeError  # :nodoc: #
-  end
-
 end