robust_excel_ole 0.3.5 → 0.3.6

data/lib/robust_excel_ole/bookstore.rb

@@ -6,18 +6,20 @@ module RobustExcelOle
   class Bookstore
 
     def initialize
-      @filename2books = Hash.new {|hash, key| hash[key] = [] }
+      @filename2books ||= Hash.new {|hash, key| hash[key] = [] }
       @hidden_excel_instance = nil
     end
 
     # returns a book with the given filename, if it was open once
     # prefers open books to closed books, and among them, prefers more recently opened books
     # excludes hidden Excel instance
-    # options: :prefer_writable   return the writable book, if it is open (default: true)
-    #                             otherwise return the book according to the preference order mentioned above
-    #          :prefer_excel      return the book in the given excel instance, if it exists,
-    #                             otherwise proceed according to prefer_writable 
+    # options: :prefer_writable   returns the writable book, if it is open (default: true)
+    #                             otherwise returns the book according to the preference order mentioned above
+    #          :prefer_excel      returns the book in the given Excel instance, if it exists,
+    #                             otherwise proceeds according to prefer_writable 
     def fetch(filename, options = {:prefer_writable => true })
+      return nil unless filename
+      filename = RobustExcelOle::absolute_path(filename)
       filename_key = RobustExcelOle::canonize(filename)
       weakref_books = @filename2books[filename_key]
       return nil unless weakref_books
@@ -27,7 +29,7 @@ module RobustExcelOle
           begin 
             @filename2books[filename_key].delete(wr_book)
           rescue
-            puts "Warning: deleting dead reference failed! (file: #{filename})"
+            t "Warning: deleting dead reference failed: file: #{filename.inspect}"
           end
         else
           book = wr_book.__getobj__
@@ -48,7 +50,7 @@ module RobustExcelOle
       result if result
     end
 
-    # stores a book
+    # stores a workbook
     def store(book)
       filename_key = RobustExcelOle::canonize(book.filename)      
       if book.stored_filename
@@ -60,7 +62,7 @@ module RobustExcelOle
       book.stored_filename = book.filename
     end
 
-    # creates and returns a separate Excel instance with Visible and DisplayAlerts false
+    # creates and returns a separate Excel instance with Visible and DisplayAlerts equal false
     def hidden_excel
       unless (@hidden_excel_instance &&  @hidden_excel_instance.weakref_alive? && @hidden_excel_instance.__getobj__.alive?)       
         @hidden_excel_instance = WeakRef.new(Excel.create) 
@@ -68,6 +70,21 @@ module RobustExcelOle
       @hidden_excel_instance.__getobj__
     end
 
+    # returns all stored books
+    def books
+      result = []
+      if @filename2books
+        @filename2books.each do |filename,books|
+          unless books.empty? 
+            books.each do |wr_book|
+              result << wr_book.__getobj__ if wr_book.weakref_alive?
+            end
+          end
+        end      
+      end
+      result
+    end
+
   private
 
     def try_hidden_excel
@@ -76,20 +93,19 @@ module RobustExcelOle
 
     # prints the book store
     def print
-      p "@filename2books:"
+      t "@filename2books:"
       if @filename2books
         @filename2books.each do |filename,books|
-          p " filename: #{filename}"
-          p " books:"
-          p " []" if books == []
-          if books
+          t " filename: #{filename}"
+          t " books:"
+          if books.empty? 
+            t " []" 
+          else
             books.each do |book|
               if book.weakref_alive?
-                p "#{book}"
-                p "excel: #{book.excel}"
-                p "alive: #{book.alive?}"
+                t "#{book}"
               else
-                p "weakref not alive"
+                t "weakref not alive"
               end
             end
           end

data/lib/robust_excel_ole/excel.rb

@@ -19,14 +19,17 @@ module RobustExcelOle
 
     # returns an Excel instance  
     # options:
-    #  :reuse          use an already running Excel instance (default: true)
-    #  :displayalerts  allow display alerts in Excel         (default: false)
-    #  :visible        make visible in Excel                 (default: false)
+    #  :reuse          uses an already running Excel instance (true) or 
+    #                  uses the Excel instance represented as WIN32OLE object (default: true)
+    #  :displayalerts  allows display alerts in Excel         (default: false)
+    #  :visible        makes the Excel visible                (default: false)
     #  if :reuse => true, then DisplayAlerts and Visible are set only if they are given
     def self.new(options= {})
       options = {:reuse => true}.merge(options)
-      if options[:reuse] then
+      if options[:reuse] == true then
         excel = current_excel
+      elsif options[:reuse].class == WIN32OLE then
+        excel = options[:reuse]
       end
       if not (excel)
         excel = WIN32OLE.new('Excel.Application')
@@ -45,9 +48,10 @@ module RobustExcelOle
         result = stored
       else
         result = super(options)
-        result.instance_variable_set(:@this_excel, excel)
+        result.instance_variable_set(:@ole_excel, excel)
         WIN32OLE.const_load(excel, RobustExcelOle) unless RobustExcelOle.const_defined?(:CONSTANTS)
-        @@hwnd2excel[hwnd] = result        
+        @@hwnd2excel[hwnd] = WeakRef.new(result)
+
       end
       result
     end
@@ -56,42 +60,86 @@ module RobustExcelOle
       @excel = self
     end
 
+    # reopens a closed Excel instance
+    # options: :visible (default: false), :displayalerts (default: false)
+    def recreate(opts = {})      
+      unless self.alive?
+        opts = {
+          :displayalerts => false,
+          :visible => false,
+        }.merge(opts)
+        new_excel = WIN32OLE.new('Excel.Application')
+        new_excel.DisplayAlerts = opts[:displayalerts]
+        new_excel.Visible = opts[:visible]
+        @ole_excel = new_excel 
+        books = Book.books
+        books.each do |book|
+          book.reopen if ((not book.alive?) && book.excel.alive?)
+        end        
+      end
+      self 
+    end
+
+  private
+    
+    # returns an Excel instance to which one 'connect' was possible
+    def self.current_excel   # :nodoc: #
+      result = WIN32OLE.connect('Excel.Application') rescue nil
+      if result
+        begin
+          result.Visible    # send any method, just to see if it responds
+        rescue 
+          t "dead excel " + ("Window-handle = #{result.HWnd}" rescue "without window handle")
+          return nil
+        end
+      end
+      result
+    end
+
+  public
+
     # 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) 
+    #                      :raise (default) -> raises an exception       
+    #                      :save            -> saves the workbooks before closing
+    #                      :forget          -> closes the excel instance without saving the workbooks 
+    #                      :alert           -> gives control to Excel
+    #  :hard          kills the Excel instances hard (default: false) 
     def self.close_all(options={})
       options = {
         :if_unsaved => :raise,
         :hard => false
-      }.merge(options)
+      }.merge(options)      
+      excels_number = excel_processes.size
+      # kill hard if the number of Excel instqnces does not decrease
       while current_excel do
-        #current_excel.close(options)
-        close_one_excel
+        close_one_excel(options)
         GC.start
         sleep 0.3
-        # free_all_ole_objects if options[:hard] ???
+        current_excels_number = excel_processes.size
+        (current_excels_number < excels_number) ? (excels_number = current_excels_number) : kill_all
       end
+      init
+      kill_all if options[:hard]
     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? 
+    def self.init
+      @@hwnd2excel = {}
+    end
+
+  private
+
+    def self.manage_unsaved_workbooks(excel, options)
+      #this_excel = excel == 0 ? self : excel
+      unsaved_workbooks = []
+      begin
+        excel.Workbooks.each {|w| unsaved_workbooks << w unless (w.Saved || w.ReadOnly)}
+      rescue RuntimeError => msg
+        t "RuntimeError: #{msg.message}" 
+        raise ExcelErrorOpen, "Excel instance not alive or damaged" if msg.message =~ /failed to get Dispatch Interface/
+      end
+      unless unsaved_workbooks.empty? 
         case options[:if_unsaved]
         when :raise
           raise ExcelErrorClose, "Excel contains unsaved workbooks"
@@ -99,30 +147,109 @@ module RobustExcelOle
           unsaved_workbooks.each do |workbook|
             workbook.Save
           end
-          close_excel(:hard => options[:hard])
         when :forget
-          close_excel(:hard => options[:hard])
+          # nothing
         when :alert
-          with_displayalerts true do
-            unsaved_workbooks.each do |workbook|
-              workbook.Save
-            end
-            close_excel(:hard => options[:hard])
-          end
+          excel.DisplayAlerts = true
         else
-          raise ExcelErrorClose, ":if_unsaved: invalid option: #{options[:if_unsaved]}"
+          raise ExcelErrorClose, ":if_unsaved: invalid option: #{options[:if_unsaved].inspect}"
         end
-      else
-        close_excel(:hard => options[:hard])
       end
-      raise ExcelUserCanceled, "close: canceled by user" if options[:if_unsaved] == :alert && self.unsaved_workbooks
+    end
+
+    # closes one Excel instance to which one was connected
+    def self.close_one_excel(options={})
+      excel = current_excel
+      return unless excel
+      manage_unsaved_workbooks(excel, options)
+      weak_ole_excel = WeakRef.new(excel)
+      excel = nil
+      close_excel_ole_instance(weak_ole_excel.__getobj__)
+    end
+
+    def self.close_excel_ole_instance(ole_excel)
+      @@hwnd2excel.delete(ole_excel.Hwnd)
+      excel = ole_excel
+      ole_excel = nil
+      begin
+        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
+            t "successfully ole_freed #{weak_excel_ref}"
+          rescue
+            t "could not do ole_free on #{weak_excel_ref}"
+          end
+        end
+        hwnd2excel(excel_hwnd).die rescue nil
+        @@hwnd2excel.delete(excel_hwnd)
+      rescue => e
+        t "Error when closing Excel: #{e.message}"
+        #t e.backtrace
+      end
+      free_all_ole_objects
+    end
+
+    # frees all OLE objects in the object space
+    def self.free_all_ole_objects   
+      anz_objekte = 0
+      ObjectSpace.each_object(WIN32OLE) do |o|
+        anz_objekte += 1
+        #t [:Name, (o.Name rescue (o.Count rescue "no_name"))]
+        #t [:ole_object_name, (o.ole_object_name rescue nil)]
+        #t [:methods, (o.ole_methods rescue nil)] unless (o.Name rescue false)
+        #t o.ole_type rescue nil
+        begin
+          o.ole_free
+          #t "olefree OK"
+        rescue
+          #t "olefree_error: #{$!}"
+          #t $!.backtrace.first(9).join "\n"
+        end
+      end
+      t "went through #{anz_objekte} OLE objects"
+    end   
+
+    # sets this Excel instance to nil
+    def die 
+      @ole_excel = nil
+    end
+
+  public
+
+    # closes the Excel
+    #  :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 
+    #                      :alert           -> gives control to Excel
+    #  :hard          kill the Excel instance hard (default: false) 
+    def close(options = {})
+      options = {
+        :if_unsaved => :raise,
+        :hard => false
+      }.merge(options)
+      self.class.manage_unsaved_workbooks(@ole_excel, options)
+      close_excel(options)
     end
 
   private
 
     def close_excel(options)
-      excel = @this_excel
-      excel.Workbooks.Close
+      excel = @ole_excel
+      begin
+        excel.Workbooks.Close
+      rescue WIN32OLERuntimeError => msg
+        raise ExcelUserCanceled, "close: canceled by user" if msg.message =~ /80020009/ && 
+              options[:if_unsaved] == :alert && (not self.unsaved_workbooks.empty?)
+      end
       excel_hwnd = excel.HWnd
       excel.Quit
       weak_excel_ref = WeakRef.new(excel)
@@ -133,55 +260,95 @@ module RobustExcelOle
         #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}"
+          t "successfully ole_freed #{weak_excel_ref}"
+        rescue => msg
+          t "#{msg.message}"
+          t "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
+      @@hwnd2excel.delete(excel_hwnd)      
       if options[:hard] then
+        Excel.free_all_ole_objects
         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)    
+        Process.kill("KILL", pid) rescue nil   
       end
     end
 
   public
 
-    def excel
-      self
+    # kill all Excel instances
+    def self.kill_all
+      procs = WIN32OLE.connect("winmgmts:\\\\.")
+      processes = procs.InstancesOf("win32_process")
+      number = processes.select{|p| (p.name == "EXCEL.EXE")}.size
+      procs.InstancesOf("win32_process").each do |p|
+        Process.kill('KILL', p.processid) if p.name == "EXCEL.EXE"        
+      end
+      number
     end
 
-    # generate, save and close an empty workbook
-    def generate_workbook file_name                  
-      self.Workbooks.Add                           
-      empty_workbook = self.Workbooks.Item(self.Workbooks.Count)          
-      filename = RobustExcelOle::absolute_path(file_name).gsub("/","\\")
-      unless File.exists?(filename)
-        begin
-          empty_workbook.SaveAs(filename) 
-        rescue WIN32OLERuntimeError => msg
-          if msg.message =~ /SaveAs/ and msg.message =~ /Workbook/ then
-            raise ExcelErrorSave, "could not save workbook with filename #{file_name}"
-          else
-            # todo some time: find out when this occurs : 
-            raise ExcelErrorSaveUnknown, "unknown WIN32OELERuntimeError with filename #{file_name}: \n#{msg.message}"
+    # provide Excel objects 
+    # (so far restricted to all Excel instances opened with RobustExcelOle,
+    #  not for Excel instances opened by the user)
+    def self.excel_processes
+      pid2excel = {}
+      @@hwnd2excel.each do |hwnd,wr_excel|
+        process_id = Win32API.new("user32", "GetWindowThreadProcessId", ["I","P"], "I")
+        pid_puffer = " " * 32
+        process_id.call(hwnd, pid_puffer)
+        pid = pid_puffer.unpack("L")[0]
+        pid2excel[pid] = wr_excel
+      end
+      procs = WIN32OLE.connect("winmgmts:\\\\.")
+      processes = procs.InstancesOf("win32_process")     
+      result = []
+      processes.each do |p|
+        if p.name == "EXCEL.EXE"
+          if pid2excel.include?(p.processid)
+            excel = pid2excel[p.processid].__getobj__ 
+            result << excel
           end
-        end      
+          # how to connect with an Excel instance that is not in hwnd2excel (uplifting Excel)?
+          #excel = Excel.uplift unless (excel && excel.alive?)
+        end
       end
-      empty_workbook                               
+      result
+    end
+
+    def excel
+      self
     end
 
     def self.hwnd2excel(hwnd)
-      @@hwnd2excel[hwnd]
+      excel_weakref = @@hwnd2excel[hwnd]
+      if excel_weakref
+        if excel_weakref.weakref_alive?
+          excel_weakref.__getobj__
+        else
+          t "dead reference to an Excel"
+          begin 
+            @@hwnd2excel.delete(hwnd)
+          rescue
+            t "Warning: deleting dead reference failed! (hwnd: #{hwnd.inspect})"
+          end
+        end
+      end
     end
 
     def hwnd
-      self.Hwnd
+      self.Hwnd rescue nil
+    end
+
+    def self.print_hwnd2excel
+      @@hwnd2excel.each do |hwnd,wr_excel|
+        excel_string = (wr_excel.weakref_alive? ? wr_excel.__getobj__.to_s : "weakref not alive") 
+        printf("hwnd: %8i => excel: %s\n", hwnd, excel_string)
+      end
+      @@hwnd2excel.size
     end
 
     # returns true, if the Excel instances are alive and identical, false otherwise
@@ -189,66 +356,86 @@ module RobustExcelOle
       self.Hwnd == other_excel.Hwnd    if other_excel.is_a?(Excel) && self.alive? && other_excel.alive?
     end
 
-    # returns true, if the Excel instances responds to VVA methods, false otherwise
+    # returns true, if the Excel instances responds to VBA methods, false otherwise
     def alive?
-      @this_excel.Name
+      @ole_excel.Name
       true
     rescue
-      #puts $!.message
+      #t $!.message
       false
     end
 
     def print_workbooks
-      self.Workbooks.each {|w| puts w.Name}
+      self.Workbooks.each {|w| t "#{w.Name} #{w}"}
     end
 
+    # returns all unsaved workbooks
     def unsaved_workbooks
       result = []
       begin
         self.Workbooks.each {|w| result << w unless (w.Saved || w.ReadOnly)}
       rescue RuntimeError => msg
-        puts "RuntimeError: #{msg.message}" 
+        t "RuntimeError: #{msg.message}" 
         raise ExcelErrorOpen, "Excel instance not alive or damaged" if msg.message =~ /failed to get Dispatch Interface/
       end
-      result
+      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
+    # empty workbook is generated, saved and closed 
+    def generate_workbook file_name                  
+      self.Workbooks.Add                           
+      empty_workbook = self.Workbooks.Item(self.Workbooks.Count)          
+      filename = RobustExcelOle::absolute_path(file_name).gsub("/","\\")
+      unless File.exists?(filename)
+        begin
+          empty_workbook.SaveAs(filename) 
+        rescue WIN32OLERuntimeError => msg
+          if msg.message =~ /SaveAs/ and msg.message =~ /Workbook/ then
+            raise ExcelErrorSave, "could not save workbook with filename #{file_name.inspect}"
+          else
+            # todo some time: find out when this occurs : 
+            raise ExcelErrorSaveUnknown, "unknown WIN32OELERuntimeError with filename #{file_name.inspect}: \n#{msg.message}"
+          end
+        end      
+      end
+      empty_workbook                               
+    end
+
+    # sets DisplayAlerts in a block
     def with_displayalerts displayalerts_value
-      old_displayalerts = @this_excel.DisplayAlerts
-      @this_excel.DisplayAlerts = displayalerts_value
+      old_displayalerts = @ole_excel.DisplayAlerts
+      @ole_excel.DisplayAlerts = displayalerts_value
       begin
          yield self
       ensure
-        @this_excel.DisplayAlerts = old_displayalerts
+        @ole_excel.DisplayAlerts = old_displayalerts if alive?
       end
     end
 
-    # enable DisplayAlerts in the current Excel instance
+    # enables DisplayAlerts in the current Excel instance
     def displayalerts= displayalerts_value
-      @this_excel.DisplayAlerts = displayalerts_value
+      @ole_excel.DisplayAlerts = displayalerts_value
     end
 
     # return if in the current Excel instance DisplayAlerts is enabled
     def displayalerts 
-      @this_excel.DisplayAlerts
+      @ole_excel.DisplayAlerts
     end
 
-    # make the current Excel instance visible or invisible
+    # makes the current Excel instance visible or invisible
     def visible= visible_value
-      @this_excel.Visible = visible_value
+      @ole_excel.Visible = visible_value
     end
 
-    # return if the current Excel instance is visible
+    # returns whether the current Excel instance is visible
     def visible 
-      @this_excel.Visible
-    end
+      @ole_excel.Visible
+    end    
 
     def to_s
-      "#<" + "EXCEL:#{hwnd_xxxx}" + ("#{"not alive" unless self.alive?}") + ">"
+      "#<Excel: " + "#{hwnd}" + ("#{"not alive" unless self.alive?}") + ">"
     end
 
     def inspect
@@ -257,109 +444,14 @@ module RobustExcelOle
 
   private
 
-    # closes one Excel instance
-    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
-        weak_excel_ref = WeakRef.new(excel)
-        excel = nil
-        GC.start
-        sleep 0.2
-        #sleep 0.1
-        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
-
-      rescue => e
-        puts "Error when closing Excel: " + e.message
-        #puts e.backtrace
-      end
-
-
-      free_all_ole_objects
-
-      return
-      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
-
-    # frees all OLE objects in the object space
-    def self.free_all_ole_objects   
-      anz_objekte = 0
-      ObjectSpace.each_object(WIN32OLE) do |o|
-        anz_objekte += 1
-        #p [:Name, (o.Name rescue (o.Count rescue "no_name"))]
-        #p [:ole_object_name, (o.ole_object_name rescue nil)]
-        #p [:methods, (o.ole_methods rescue nil)] unless (o.Name rescue false)
-        #puts o.ole_type rescue nil
-        #trc_info :obj_hwnd, o.HWnd rescue   nil
-        #trc_info :obj_Parent, o.Parent rescue nil
-        begin
-          o.ole_free
-          #puts "olefree OK"
-        rescue
-          #puts "olefree_error: #{$!}"
-          #puts $!.backtrace.first(9).join "\n"
-        end
-      end
-      puts "went through #{anz_objekte} OLE objects"
-    end
-
-    # returns the current Excel instance
-    def self.current_excel   # :nodoc: #
-      result = WIN32OLE.connect('Excel.Application') rescue nil
-      if result
-        begin
-          result.Visible    # send any method, just to see if it responds
-        rescue 
-          puts "dead excel app " + ("Window-handle = #{result.HWnd}" rescue "without window handle")
-          return nil
-        end
-      end
-      result
-    end
-
-    def hwnd_xxxx  
-      self.HWnd #rescue Win32 nil
-    end
-
-    # set this Excel instance to nil
-    def die 
-      @this_excel = nil
-    end
-
     def method_missing(name, *args) 
       if name.to_s[0,1] =~ /[A-Z]/ 
-        begin
-          @this_excel.send(name, *args)
+        begin          
+          raise ExcelError, "method missing: Excel not alive" unless alive?
+          @ole_excel.send(name, *args)
         rescue WIN32OLERuntimeError => msg
           if msg.message =~ /unknown property or method/
-            raise VBAMethodMissingError, "unknown VBA property or method #{name}"
+            raise VBAMethodMissingError, "unknown VBA property or method #{name.inspect}"
           else 
             raise msg
           end