robust_excel_ole 0.3.5 → 0.3.6

data/examples/edit_sheets/example_naming.rb

@@ -21,6 +21,7 @@ begin
   #base_name = workbook_name.sub(/^.*(\.[^.])$/; '')
   #base_name = workbook_name[0,workbook_name.rindex('.')]
   #suffix = workbook_name[workbook_name.rindex('.')+1,workbook_name.length]
+  #suffix = workbook_name.scan(/\.[^.\/]+$/).last
   file_name = dir + "/" + workbook_name
   extended_file_name = dir + "/" + base_name + "_named" + "." + suffix
   FileUtils.copy file_name, extended_file_name 

data/lib/reo_console.rb

@@ -0,0 +1,52 @@
+
+
+#require 'lib/robust_excel_ole'
+include REO
+
+require 'irb/completion'
+require 'irb/ext/save-history'
+
+ARGV.concat [ "--readline",
+              "--prompt-mode",
+              "simple" ]
+
+# 250 entries in the list
+IRB.conf[:SAVE_HISTORY] = 250
+
+# Store results in home directory with specified file name
+#IRB.conf[:HISTORY_FILE] = "#{ENV['HOME']}/.irb-history"
+IRB.conf[:HISTORY_FILE] = "#{ENV['HOME']}/.reo-history"
+
+module Readline   # :nodoc: #
+  module Hist     # :nodoc: #
+    LOG = IRB.conf[:HISTORY_FILE]
+#    LOG = "#{ENV['HOME']}/.irb-history"
+
+    def self.write_log(line)
+      File.open(LOG, 'ab') {|f| f << "#{line}
+"}
+    end
+
+    def self.start_session_log
+      timestamp = proc{ Time.now.strftime("%Y-%m-%d, %H:%M:%S")}
+      class <<timestamp  # :nodoc: #
+        alias to_s call
+      end   
+      write_log(          "###### session start: #{timestamp}")
+      at_exit { write_log("###### session stop:  #{timestamp}") }
+    end
+  end
+
+  alias :old_readline :readline
+  def readline(*args)
+    ln = old_readline(*args)
+    begin
+      Hist.write_log(ln)
+    rescue
+    end
+    ln
+  end
+end
+
+Readline::Hist.start_session_log
+puts "REO console started"

data/lib/robust_excel_ole.rb

@@ -11,8 +11,34 @@ require File.join(File.dirname(__FILE__), 'robust_excel_ole/version')
 
 REO = RobustExcelOle
 
+include Enumerable
+
+LOG_TO_STDOUT = true
+
+REO_LOG_FILE = "reo.log"
+REO_LOG_DIR = ""
+
+File.delete REO_LOG_FILE rescue nil
+
 module RobustExcelOle
 
+  def t(text)
+    if LOG_TO_STDOUT 
+      puts text
+    else
+      if REO_LOG_DIR.empty?
+        homes = ["HOME", "HOMEPATH"]
+        home = homes.detect {|h| ENV[h] != nil}
+        reo_log_dir = ENV[home]
+      else
+        reo_log_dir = REO_LOG_DIR
+      end
+      File.open(reo_log_dir + "/" + REO_LOG_FILE,"a") do | file |
+        file.puts text
+      end
+    end
+  end
+
   def absolute_path(file)
     file = File.expand_path(file)
     file = RobustExcelOle::Cygwin.cygpath('-w', file) if RUBY_PLATFORM =~ /cygwin/
@@ -20,25 +46,33 @@ module RobustExcelOle
   end
 
   def canonize(filename)
-    raise "No string given to canonize, but #{filename.inspect}" unless filename.is_a?(String)
-    filename.downcase rescue nil
+    raise ExcelError, "No string given to canonize, but #{filename.inspect}" unless filename.is_a?(String)  
+    normalize(filename).downcase rescue nil
+  end
+
+  def normalize(path)
+    path = path.gsub('/./', '/') + '/'
+    path = path.gsub(/[\/\\]+/, "/")
+    nil while path.gsub!(/(\/|^)(?!\.\.?)([^\/]+)\/\.\.\//, '\1') 
+    path = path.chomp("/")
+    path
   end
 
-  module_function :absolute_path, :canonize
+  module_function :t, :absolute_path, :canonize
 
   class VBAMethodMissingError < RuntimeError  # :nodoc: #
   end
 
 end
 
-class Object
+class Object      # :nodoc: #
   def excel
-    raise ExcelErrorOpen, "provided instance is neither an Excel nor a Book"
+    raise ExcelError, "receiver instance is neither an Excel nor a Book"
   end
 
 end
 
-class ::String
+class ::String    # :nodoc: #
   def / path_part
     if empty?
       path_part
@@ -96,7 +130,7 @@ class ::String
 end
 
 # taken from http://api.rubyonrails.org/v2.3.8/classes/ActiveSupport/CoreExtensions/Module.html#M000806
-class Module
+class Module   # :nodoc: #
   def parent_name
     unless defined? @parent_name
       @parent_name = name =~ /::[^:]+\Z/ ? $`.freeze : nil

data/lib/robust_excel_ole/book.rb

@@ -14,7 +14,7 @@ module RobustExcelOle
       DEFAULT_OPEN_OPTS = { 
         :excel => :reuse,
         :default_excel => :reuse,
-        :if_lockraiseed     => :readonly,       
+        :if_lockraiseed => :readonly,       
         :if_unsaved    => :raise,
         :if_obstructed => :raise,
         :if_absent     => :raise,
@@ -23,73 +23,101 @@ module RobustExcelOle
 
     class << self
       
-      # opens a book.
+      # opens a workbook.
       # 
-      # when reopening a book that was opened and closed before, transparency identity is ensured:
+      # when reopening a workbook that was opened and closed before, transparency identity is ensured:
       # same Book objects refer to the same Excel files, and vice versa
       # 
       # options: 
-      # :default_excel   if the book was already open in an Excel instance, then open it there.
-      #                  Otherwise, i.e. if the book was not open before or the Excel instance is not alive
-      #                   :reuse (default) -> connect to a (the first opened) running Excel instance,
+      # :default_excel   if the workbook was already open in an Excel instance, then open it there.
+      #                  Otherwise, i.e. if the workbook was not open before or the Excel instance is not alive
+      #                   :reuse (default) -> connects to a (the first opened) running Excel instance,
       #                                        excluding the hidden Excel instance, if it exists,
-      #                                       otherwise open in a new Excel instance.
-      #                   :new             -> open in a new Excel instance
-      #                   <excel-instance> -> open in the given Excel instance
-      # :force_excel     no matter whether the book was already open
-      #                   :new (default)   -> open in a new Excel
-      #                   <excel-instance> -> open in the given Excel instance
-      # :if_unsaved     if an unsaved book with the same name is open, then
-      #                  :raise (default)              -> raise an exception
-      #                  :forget              -> close the unsaved book, open the new book             
-      #                  :accept              -> let the unsaved book open                  
-      #                  :alert               -> give control to Excel
-      #                  :new_excel           -> open the new book in a new Excel
-      # :if_obstructed  if a book with the same name in a different path is open, then
-      #                  :raise (default)     -> raise an exception 
-      #                  :forget              -> close the old book, open the new book
-      #                  :save                -> save the old book, close it, open the new book
-      #                  :close_if_saved      -> close the old book and open the new book, if the old book is saved,
-      #                                          otherwise raise an exception.
-      #                  :new_excel           -> open the new book in a new Excel    
+      #                                       otherwise opens in a new Excel instance.
+      #                   :new             -> opens in a new Excel instance
+      #                   <excel-instance> -> opens in the given Excel instance
+      # :force_excel     no matter whether the workbook was already open
+      #                   :new (default)   -> opens in a new Excel instance
+      #                   <excel-instance> -> opens in the given Excel instance
+      # :if_unsaved     if an unsaved workbook with the same name is open, then
+      #                  :raise (default)     -> raises an exception
+      #                  :forget              -> close the unsaved workbook, open the new workbook             
+      #                  :accept              -> lets the unsaved workbook open                  
+      #                  :alert               -> gives control to Excel
+      #                  :new_excel           -> opens the new workbook in a new Excel instance
+      # :if_obstructed  if a workbook with the same name in a different path is open, then
+      #                  :raise (default)     -> raises an exception 
+      #                  :forget              -> closes the old workbook, open the new workbook
+      #                  :save                -> saves the old workbook, close it, open the new workbook
+      #                  :close_if_saved      -> closes the old workbook and open the new workbook, if the old workbook is saved,
+      #                                          otherwise raises an exception.
+      #                  :new_excel           -> opens the new workbook in a new Excel instance   
       # :if_absent       :raise (default)     -> raises an exception     , if the file does not exists
       #                  :create              -> creates a new Excel file, if it does not exists  
       #                  
-      # :read_only     open in read-only mode         (default: false) 
-      # :displayalerts enable DisplayAlerts in Excel  (default: false)
-      # :visible       make visible in Excel          (default: false)
+      # :read_only     opens in read-only mode         (default: false) 
+      # :displayalerts enables DisplayAlerts in Excel  (default: false)
+      # :visible       makes visible in Excel          (default: false)
       # if :default_excel is set, then DisplayAlerts and Visible are set only if these parameters are given
 
       def open(file, opts={ }, &block)
-        current_options = DEFAULT_OPEN_OPTS.merge(opts)
+        options = DEFAULT_OPEN_OPTS.merge(opts)
         book = nil
-        if (not (current_options[:force_excel] == :new && (not current_options[:if_locked] == :take_writable)))
+        if (not (options[:force_excel] == :new && (not options[:if_locked] == :take_writable)))
           # if readonly is true, then prefer a book that is given in force_excel if this option is set
           book = bookstore.fetch(file, 
-                  :prefer_writable => (not current_options[:read_only]), 
-                  :prefer_excel    => (current_options[:read_only] ? current_options[:force_excel].excel : nil)) rescue nil
+                  :prefer_writable => (not options[:read_only]), 
+                  :prefer_excel    => (options[:read_only] ? options[:force_excel].excel : nil)) rescue nil
           if book
-            if (((not current_options[:force_excel]) || (current_options[:force_excel].excel == book.excel)) &&
-                 (not (book.alive? && (not book.saved) && (not current_options[:if_unsaved] == :accept))))
+            if (((not options[:force_excel]) || (options[:force_excel].excel == book.excel)) &&
+                 (not (book.alive? && (not book.saved) && (not options[:if_unsaved] == :accept))))
               book.options = DEFAULT_OPEN_OPTS.merge(opts)
-              book.get_excel unless book.excel.alive?
+              book.ensure_excel(options) unless book.excel.alive?
               # if the book is opened as readonly and should be opened as writable, then close it and open the book with the new readonly mode
-              book.close if (book.alive? && (not book.writable) && (not current_options[:read_only]))
-              # reopen the book
-              book.get_workbook(file) unless book.alive?
+              book.close if (book.alive? && (not book.writable) && (not options[:read_only]))
+              # reopens the book
+              book.ensure_workbook(file,options) unless book.alive?
               return book
             end
           end
         end
-        current_options[:excel] = current_options[:force_excel] ? current_options[:force_excel] : current_options[:default_excel]
-        new(file, current_options, &block)
+        #options[:excel] = options[:force_excel] ? options[:force_excel] : options[:default_excel]
+        new(file, options, &block)
+      end
+    end    
+
+    # creates a Book object for a given workbook or file name
+    def self.new(workbook, opts={ }, &block)      
+      if workbook && workbook.class == WIN32OLE
+        filename = workbook.Fullname.tr('\\','/') rescue nil
+        if filename
+          book = bookstore.fetch(filename)
+          return book if book && book.alive?
+        end
+      end
+      super
+    end
+
+    # creates a new Book object, if a file name is given
+    # lifts the workbook to a Book object, if a workbook is given    
+    def initialize(file_or_workbook, opts={ }, &block)
+      options = DEFAULT_OPEN_OPTS.merge(opts)
+      options[:excel] = options[:force_excel] ? options[:force_excel] : options[:default_excel]
+      if file_or_workbook.class == WIN32OLE
+        workbook = file_or_workbook
+        @workbook = workbook        
+        # use the Excel instance where the workbook is opened
+        win32ole_excel = WIN32OLE.connect(workbook.Fullname).Application rescue nil   
+        options = {:reuse => win32ole_excel}.merge(options)
+        @excel = Excel.new(options)     
+        # if the Excel could not be lifted up, then create it         
+        ensure_excel(options) unless (@excel && @excel.alive?)
+        t "@excel: #{@excel}"
+      else
+        file = file_or_workbook
+        ensure_excel(options)
+        ensure_workbook(file, options)
       end
-    end
-
-    def initialize(file, opts={ }, &block)
-      @options = DEFAULT_OPEN_OPTS.merge(opts)      
-      get_excel
-      get_workbook file
       bookstore.store(self)
       if block
         begin
@@ -100,49 +128,42 @@ module RobustExcelOle
       end
     end
 
-    def self.excel_class
-      @excel_class ||= begin
-        module_name = self.parent_name
-        "#{module_name}::Excel".constantize
-      rescue NameError => e
-        Excel
-      end
-    end
-
-    def excel_class
-      self.class.excel_class
-    end
-
-    
-    def get_excel
-      if @options[:excel] == :reuse
+    def ensure_excel(options)
+      if options[:excel] == :reuse
         @excel = excel_class.new(:reuse => true)
       end
-      @excel_options = nil
-      if (not @excel)
-        if @options[:excel] == :new
-          @excel_options = {:displayalerts => false, :visible => false}.merge(@options)
-          @excel_options[:reuse] = false
-          @excel = excel_class.new(@excel_options)
-        else
-          @excel = @options[:excel].excel
+      excel_options = nil
+      if @excel 
+        dead_or_recycled = begin
+          (not @excel.alive?)
+        rescue WeakRef::RefError => msg
+          true
+        end
+      end
+      if (not @excel) || dead_or_recycled
+        if options[:excel] == :new || dead_or_recycled
+          excel_options = {:displayalerts => false, :visible => false}.merge(options)
+          excel_options[:reuse] = false
+          @excel = excel_class.new(excel_options)
+        else 
+          @excel = options[:excel].excel
         end
       end
       # if :excel => :new or (:excel => :reuse but could not reuse)
       #   keep the old values for :visible and :displayalerts, set them only if the parameters are given
-      if (not @excel_options)
-        @excel.displayalerts = @options[:displayalerts] unless @options[:displayalerts].nil?
-        @excel.visible = @options[:visible] unless @options[:visible].nil?
+      if (not excel_options)
+        @excel.displayalerts = options[:displayalerts] unless options[:displayalerts].nil?
+        @excel.visible = options[:visible] unless options[:visible].nil?
       end
     end
 
-    def get_workbook file
+    def ensure_workbook(file, options)
       file = @stored_filename ? @stored_filename : file
       unless File.exist?(file)
-        if @options[:if_absent] == :create
+        if options[:if_absent] == :create
           @workbook = excel_class.current.generate_workbook(file)
         else 
-          raise ExcelErrorOpen, "file #{file} not found"
+          raise ExcelErrorOpen, "file #{file.inspect} not found"
         end
       end
       @workbook = @excel.Workbooks.Item(File.basename(file)) rescue nil
@@ -151,104 +172,119 @@ module RobustExcelOle
                                    (not (RobustExcelOle::absolute_path(file) == @workbook.Fullname))
         # if book is obstructed by a book with same name and different path
         if obstructed_by_other_book then
-          case @options[:if_obstructed]
+          case options[:if_obstructed]
           when :raise
-            raise ExcelErrorOpen, "blocked by a book with the same name in a different path: #{File.basename(file)}"
+            raise ExcelErrorOpen, "blocked by a book with the same name in a different path: #{File.basename(file).inspect}"
           when :forget
             @workbook.Close
             @workbook = nil
-            open_or_create_workbook file
+            open_or_create_workbook(file, options)
           when :save
             save unless @workbook.Saved
             @workbook.Close
             @workbook = nil
-            open_or_create_workbook file
+            open_or_create_workbook(file, options)
           when :close_if_saved
             if (not @workbook.Saved) then
-              raise ExcelErrorOpen, "book with the same name in a different path is unsaved: #{File.basename(file)}"
+              raise ExcelErrorOpen, "workbook with the same name in a different path is unsaved: #{File.basename(file).inspect}"
             else 
               @workbook.Close
               @workbook = nil
-              open_or_create_workbook file
+              open_or_create_workbook(file, options)
             end
           when :new_excel 
-            @excel_options = {:displayalerts => false, :visible => false}.merge(@options)   
-            @excel_options[:reuse] = false
-            @excel = excel_class.new(@excel_options)
-            open_or_create_workbook file
+            excel_options = {:displayalerts => false, :visible => false}.merge(options)   
+            excel_options[:reuse] = false
+            @excel = excel_class.new(excel_options)
+            open_or_create_workbook(file, options)
           else
-            raise ExcelErrorOpen, ":if_obstructed: invalid option: #{@options[:if_obstructed]}"
+            raise ExcelErrorOpen, ":if_obstructed: invalid option: #{options[:if_obstructed].inspect}"
           end
         else
           # book open, not obstructed by an other book, but not saved and writable
           if (not @workbook.Saved) then
-            case @options[:if_unsaved]
+            case options[:if_unsaved]
             when :raise
-              raise ExcelErrorOpen, "book is already open but not saved (#{File.basename(file)})"
+              raise ExcelErrorOpen, "workbook is already open but not saved: #{File.basename(file).inspect}"
             when :forget
               @workbook.Close
               @workbook = nil
-              open_or_create_workbook file
+              open_or_create_workbook(file, options)
             when :accept
               # do nothing
             when :alert
               @excel.with_displayalerts true do
-                open_or_create_workbook file
+                open_or_create_workbook(file,options)
               end 
             when :new_excel
-              @excel_options = {:displayalerts => false, :visible => false}.merge(@options)
-              @excel_options[:reuse] = false
-              @excel = excel_class.new(@excel_options)
-              open_or_create_workbook file
+              excel_options = {:displayalerts => false, :visible => false}.merge(options)
+              excel_options[:reuse] = false
+              @excel = excel_class.new(excel_options)
+              open_or_create_workbook(file, options)
             else
-              raise ExcelErrorOpen, ":if_unsaved: invalid option: #{@options[:if_unsaved]}"
+              raise ExcelErrorOpen, ":if_unsaved: invalid option: #{options[:if_unsaved].inspect}"
             end
           end
         end
       else
         # book is not open
-        open_or_create_workbook file
+        open_or_create_workbook(file, options)
       end
     end
 
-    def open_or_create_workbook file
-      if ((not @workbook) || (@options[:if_unsaved] == :alert) || @options[:if_obstructed]) then
+  private
+
+    def open_or_create_workbook(file, options)
+      if ((not @workbook) || (options[:if_unsaved] == :alert) || options[:if_obstructed]) then
         begin
           filename = RobustExcelOle::absolute_path(file)
           begin
             workbooks = @excel.Workbooks
           rescue RuntimeError => msg
-            puts "RuntimeError: #{msg.message}" 
-            raise ExcelErrorOpen, "Excel instance not alive or damaged" if msg.message =~ /failed to get Dispatch Interface/
+            t "RuntimeError: #{msg.message}" 
+            if msg.message =~ /method missing: Excel not alive/
+              raise ExcelErrorOpen, "Excel instance not alive or damaged" 
+            else
+              raise ExcelErrorOpen, "unknown RuntimeError"
+            end
+          rescue WeakRef::RefError => msg
+            t "WeakRefError: #{msg.message}"
+            raise ExcelErrorOpen, "#{msg.message}"
           end
-          workbooks.Open(filename,{ 'ReadOnly' => @options[:read_only] })
+          workbooks.Open(filename,{ 'ReadOnly' => options[:read_only] })
         rescue WIN32OLERuntimeError => msg
-          puts "WIN32OLERuntimeError: #{msg.message}" 
-          raise ExcelErrorOpen, "open: user canceled or open error" if msg.message =~ /800A03EC/
+          t "WIN32OLERuntimeError: #{msg.message}" 
+          if msg.message =~ /800A03EC/
+            raise ExcelErrorOpen, "open: user canceled or open error"
+          else 
+            raise ExcelErrorOpen, "unknown WIN32OLERuntimeError"
+          end
         end   
         begin
           # workaround for bug in Excel 2010: workbook.Open does not always return 
           # the workbook with given file name
           @workbook = workbooks.Item(File.basename(filename))
         rescue WIN32OLERuntimeError
-          raise ExcelErrorOpen, "open: item error"
+          raise ExcelErrorOpen, "cannot find the file #{File.basename(filename).inspect}"
         end
       end
     end
 
-    # closes the book, if it is alive
+  public
+
+    # closes the workbook, if it is alive
     #
     # options:
-    #  :if_unsaved    if book is unsaved
-    #                      :raise (default) -> raise an exception       
-    #                      :save            -> save the book before it is closed                  
-    #                      :forget          -> close the book 
-    #                      :alert           -> give control to excel
+    #  :if_unsaved    if the workbook is unsaved
+    #                      :raise (default) -> raises an exception       
+    #                      :save            -> saves the workbook before it is closed                  
+    #                      :forget          -> closes the workbook 
+    #                      :alert           -> gives control to excel
     def close(opts = {:if_unsaved => :raise})
       if (alive? && (not @workbook.Saved) && writable) then
         case opts[:if_unsaved]
         when :raise
-          raise ExcelErrorClose, "book is unsaved (#{File.basename(self.stored_filename)})"
+          raise ExcelErrorClose, "workbook is unsaved: #{File.basename(self.stored_filename).inspect}"
         when :save
           save
           close_workbook
@@ -259,7 +295,7 @@ module RobustExcelOle
             close_workbook
           end
         else
-          raise ExcelErrorClose, ":if_unsaved: invalid option: #{opts[:if_unsaved]}"
+          raise ExcelErrorClose, ":if_unsaved: invalid option: #{opts[:if_unsaved].inspect}"
         end
       else
         close_workbook
@@ -292,17 +328,17 @@ module RobustExcelOle
       unobtrusively(*args, &block)
     end
 
-    # modify a book such that its state (open/close, saved/unsaved, readonly/writable) remains unchanged.
+    # modifies a workbook such that its state (open/close, saved/unsaved, readonly/writable) remains unchanged.
     #  options:
-    #  :reuse (default)  : open closed books in the Excel instance of the book, if it exists, reuse another Excel, otherwise          
-    #  :hidden           : open closed books in one separate Excel instance that is not visible and has no displayaslerts    
-    #  <excel-instance>  : open closed books in the given Excel instance
-    #  :read_only: Open the book unobtrusively for reading only  (default: false)
-    #  :readonly_excel:  if the book is opened only as ReadOnly and shall be modified, then
-    #                    true:  close it and open it as writable in the excel instance where it was open so far
-    #                    false (default)   open it as writable in another running excel instance, if it exists,
-    #                                      otherwise open in a new excel instance.
-    #  :keep_open: let the book open after unobtrusively opening (default: false)
+    #  :reuse (default)  : opens closed workbooks in the Excel instance of the workbook, if it exists, reuse another Excel, otherwise          
+    #  :hidden           : opens closed workbooks in one separate Excel instance that is not visible and has no displayaslerts    
+    #  <excel-instance>  : opens closed workbooks in the given Excel instance
+    #  :read_only        : opens the workbook unobtrusively for reading only  (default: false)
+    #  :readonly_excel:  if the workbook is opened only as ReadOnly and shall be modified, then
+    #                    true:  closes it and open it as writable in the Excel instance where it was open so far
+    #                    false (default)   opens it as writable in another running excel instance, if it exists,
+    #                                      otherwise open in a new Excel instance.
+    #  :keep_open: lets the workbook open after unobtrusively opening (default: false)
     def self.unobtrusively(file, if_closed = nil, opts = { }, &block) 
       if if_closed.is_a? Hash
         opts = if_closed
@@ -316,6 +352,14 @@ module RobustExcelOle
       }.merge(opts)
       book = bookstore.fetch(file, :prefer_writable => (not options[:read_only]))
       was_not_alive_or_nil = book.nil? || (not book.alive?)
+      workbook = book.excel.Workbooks.Item(File.basename(file)) rescue nil
+      now_alive = 
+        begin 
+          workbook.Name
+          true
+        rescue 
+          false
+        end
       was_saved = was_not_alive_or_nil ? true : book.saved
       was_writable = book.writable unless was_not_alive_or_nil
       begin 
@@ -344,25 +388,26 @@ module RobustExcelOle
         if (not was_not_alive_or_nil) && (not options[:read_only]) && (not was_writable) && options[:readonly_excel]
           open(file, :force_excel => book.excel, :if_obstructed => :new_excel, :read_only => true)
         end
-        book.close if (was_not_alive_or_nil && (not opts[:keep_open]) && book)
+        book.close if (was_not_alive_or_nil && (not now_alive) && (not options[:keep_open]) && book)
       end
     end
 
+    # reopens a closed workbook
     def reopen
       self.class.open(self.stored_filename)
     end
 
-    # rename a range
-    def rename_range(name,new_name)
+    # renames a range
+    def rename_range(name, new_name)
       begin
         item = self.Names.Item(name)
       rescue WIN32OLERuntimeError
-        raise ExcelError, "name #{name} not in #{File.basename(self.stored_filename)}"  
+        raise ExcelError, "name #{name.inspect} not in #{File.basename(self.stored_filename).inspect}"  
       end
       begin
         item.Name = new_name
       rescue WIN32OLERuntimeError
-        raise ExcelError, "name error in #{File.basename(self.stored_filename)}"      
+        raise ExcelError, "name error in #{File.basename(self.stored_filename).inspect}"      
       end
     end
 
@@ -374,41 +419,64 @@ module RobustExcelOle
         item = self.Names.Item(name)
       rescue WIN32OLERuntimeError
         return opts[:default] if opts[:default]
-        raise ExcelErrorNValue, "name #{name} not in #{File.basename(self.stored_filename)}"
+        raise ExcelError, "name #{name.inspect} not in #{File.basename(self.stored_filename).inspect}"
       end
       begin
         value = item.RefersToRange.Value
       rescue  WIN32OLERuntimeError
-        return opts[:default] if opts[:default]
-        raise ExcelErrorNValue, "RefersToRange error of name #{name} in #{File.basename(self.stored_filename)}"
+        begin
+          sheet = self[0]
+          value = sheet.Evaluate(name)
+        rescue WIN32OLERuntimeError
+          return opts[:default] if opts[:default]
+          raise SheetError, "cannot evaluate name #{name.inspect} in sheet"
+        end
       end
-      value
+      if value == -2146826259
+        return opts[:default] if opts[:default]
+        raise SheetError, "cannot evaluate name #{name.inspect} in sheet"
+      end 
+      return opts[:default] if (value.nil? && opts[:default])
+      value      
     end
 
     # set the contents of a range with given name
-    def set_nvalue(name,value) 
+    def set_nvalue(name, value) 
       begin
         item = self.Names.Item(name)
       rescue WIN32OLERuntimeError
-        raise ExcelErrorNValue, "name #{name} not in #{File.basename(self.stored_filename)}"  
+        raise ExcelError, "name #{name.inspect} not in #{File.basename(self.stored_filename).inspect}"  
       end
       begin
         item.RefersToRange.Value = value
       rescue WIN32OLERuntimeError
-        raise ExcelErrorNValue, "RefersToRange error of name #{name} in #{File.basename(self.stored_filename)}"    
+        raise ExcelError, "RefersToRange error of name #{name.inspect} in #{File.basename(self.stored_filename).inspect}"    
       end
     end
 
-    def activate
+    # brings the workbook to the foreground and available for heyboard inputs, and makes the Excel instance visible
+    def activate      
       @excel.visible = true
       begin
-        self.Activate
-        self.ActiveSheet.Activate
+        Win32API.new("user32","SetForegroundWindow","I","I").call(@excel.hwnd)     # Excel  2010
+        @workbook.Activate   # Excel 2007
       rescue WIN32OLERuntimeError
         raise ExcelError, "cannot activate"
       end
     end
 
+    # returns whether the workbook is visible or invisible
+    def visible
+      @excel.Windows(@workbook.Name).Visible
+    end
+
+    # makes a workbook visible or invisible
+    def visible= visible_value
+      saved = @workbook.Saved
+      @excel.Windows(@workbook.Name).Visible = visible_value
+      save if saved 
+    end
+
     # returns true, if the workbook reacts to methods, false otherwise
     def alive?
       begin 
@@ -416,7 +484,7 @@ module RobustExcelOle
         true
       rescue 
         @workbook = nil  # dead object won't be alive again
-        #puts $!.message
+        #t $!.message
         false
       end
     end
@@ -434,71 +502,108 @@ module RobustExcelOle
       @workbook.Saved if @workbook
     end
 
-    # returns true, if the full book names and excel appications are identical, false otherwise  
+    # returns true, if the full book names and excel Instances are identical, false otherwise  
     def == other_book
       other_book.is_a?(Book) &&
       @excel == other_book.excel &&
       self.filename == other_book.filename  
     end
- 
-    # saves a book.
-    # returns true, if successfully saved, nil otherwise
-    def save
-      raise ExcelErrorSave, "Not opened for writing (opened with :read_only option)" if @options[:read_only]
-      if @workbook then
-        begin
-          @workbook.Save 
-        rescue WIN32OLERuntimeError => msg
-          if msg.message =~ /SaveAs/ and msg.message =~ /Workbook/ then
-            raise ExcelErrorSave, "workbook not saved"
-          else
-            raise ExcelErrorSaveUnknown, "unknown WIN32OELERuntimeError:\n#{msg.message}"
-          end       
-        end
-        true
-      else
-        nil
+
+    def self.books
+      bookstore.books
+    end
+
+    # simple save of a workbook.
+    # returns true, if successfully saved, nil or error otherwise
+    def save      
+      raise ExcelErrorSave, "Workbook is not alive" if (not alive?)
+      raise ExcelErrorSave, "Not opened for writing (opened with :read_only option)" if @workbook.ReadOnly
+      begin
+        @workbook.Save 
+      rescue WIN32OLERuntimeError => msg
+        if msg.message =~ /SaveAs/ and msg.message =~ /Workbook/ then
+          raise ExcelErrorSave, "workbook not saved"
+        else
+          raise ExcelErrorSaveUnknown, "unknown WIN32OELERuntimeError:\n#{msg.message}"
+        end       
       end
+      true
     end
 
-    # saves a book.
+    # saves a workbook with a given file name.
     #
     # options:
     #  :if_exists   if a file with the same name exists, then  
-    #               :raise     -> raise an exception, dont't write the file  (default)
-    #               :overwrite -> write the file, delete the old file
-    #               :alert     -> give control to Excel
-    # returns true, if successfully saved, nil otherwise
-    def save_as(file = nil, opts = {:if_exists => :raise} )
-      raise IOError, "Not opened for writing(open with :read_only option)" if @options[:read_only]
-      @opts = opts
+    #               :raise     -> raises an exception, dont't write the file  (default)
+    #               :overwrite -> writes the file, delete the old file
+    #               :alert     -> gives control to Excel
+    #  :if_obstructed   if a workbook with the same name and different path is already open and blocks the saving, then
+    #                  :raise (default)     -> raises an exception 
+    #                  :forget              -> closes the blocking workbook
+    #                  :save                -> saves the blocking workbook and closes it
+    #                  :close_if_saved      -> closes the blocking workbook, if it is saved, 
+    #                                          otherwise raises an exception
+    # returns true, if successfully saved, nil or error otherwise
+    def save_as(file = nil, opts = { } )
+      raise ExcelErrorSave, "Workbook is not alive" if (not alive?)
+      raise ExcelErrorSave, "Not opened for writing (opened with :read_only option)" if @workbook.ReadOnly
+      options = {
+        :if_exists => :raise,
+        :if_obstructed => :raise,
+      }.merge(opts)
       if File.exist?(file) then
-        case @opts[:if_exists]
+        case options[:if_exists]
         when :overwrite
-          begin
-            File.delete(file) 
-          rescue Errno::EACCES
-            raise ExcelErrorSave, "book is open and used in Excel"
+          if file == self.filename
+            save
+            return
+          else
+            begin
+              File.delete(file)
+            rescue Errno::EACCES
+              raise ExcelErrorSave, "workbook is open and used in Excel"
+            end
           end
-          save_as_workbook(file)
         when :alert 
           @excel.with_displayalerts true do
-            save_as_workbook(file)
+            save_as_workbook(file, options)
           end
+          true
+          return
         when :raise
-          raise ExcelErrorSave, "book already exists: #{File.basename(file)}"
+          raise ExcelErrorSave, "file already exists: #{File.basename(file).inspect}"
         else
-          raise ExcelErrorSave, ":if_exists: invalid option: #{@opts[:if_exists]}"
+          raise ExcelErrorSave, ":if_exists: invalid option: #{options[:if_exists].inspect}"
         end
-      else
-        save_as_workbook(file)
       end
+      blocking_workbook = 
+        begin
+          @excel.Workbooks.Item(File.basename(file))
+        rescue WIN32OLERuntimeError => msg
+          nil
+        end
+      if blocking_workbook then
+        case options[:if_obstructed]
+        when :raise
+          raise ExcelErrorSave, "blocked by another workbook: #{File.basename(file).inspect}"
+        when :forget
+          # nothing
+        when :save
+          blocking_workbook.Save
+        when :close_if_saved
+          raise ExcelErrorSave, "blocking workbook is unsaved: #{File.basename(file).inspect}" unless blocking_workbook.Saved
+        else
+          raise ExcelErrorSave, ":if_obstructed: invalid option: #{options[:if_obstructed].inspect}"
+        end
+        blocking_workbook.Close
+      end
+      save_as_workbook(file, options)
       true
     end
 
   private
 
-    def save_as_workbook(file)
+    def save_as_workbook(file, options)
       begin
         dirname, basename = File.split(file)
         file_format =
@@ -511,7 +616,7 @@ module RobustExcelOle
         bookstore.store(self)
       rescue WIN32OLERuntimeError => msg
         if msg.message =~ /SaveAs/ and msg.message =~ /Workbook/ then
-          if @opts[:if_exists] == :alert then 
+          if options[:if_exists] == :alert then 
             raise ExcelErrorSave, "not saved or canceled by user"
           else
             return nil
@@ -530,24 +635,24 @@ module RobustExcelOle
     def [] name
       name += 1 if name.is_a? Numeric
       begin
-        RobustExcelOle::Sheet.new(@workbook.Worksheets.Item(name))
+        sheet_class.new(@workbook.Worksheets.Item(name))
       rescue WIN32OLERuntimeError => msg
         if msg.message =~ /8002000B/
           nvalue(name)
         else
-          raise ExcelError, "could neither return a sheet nor a value of a range when giving the name #{name}"
+          raise ExcelError, "could neither return a sheet nor a value of a range when giving the name #{name.inspect}"
         end
       end
     end
 
-    # set the value of a range given its name
+    # sets the value of a range given its name
     def []= (name, value)
       set_nvalue(name,value)
     end
 
     def each
       @workbook.Worksheets.each do |sheet|
-        yield RobustExcelOle::Sheet.new(sheet)
+        yield sheet_class.new(sheet)
       end
     end
 
@@ -558,17 +663,17 @@ module RobustExcelOle
       end
       new_sheet_name = opts.delete(:as)
       ws = @workbook.Worksheets
-      after_or_before, base_sheet = opts.to_a.first || [:after, Sheet.new(ws.Item(ws.Count))]
+      after_or_before, base_sheet = opts.to_a.first || [:after, sheet_class.new(ws.Item(ws.Count))]
       base_sheet = base_sheet.worksheet
       sheet ? sheet.Copy({ after_or_before.to_s => base_sheet }) : @workbook.WorkSheets.Add({ after_or_before.to_s => base_sheet })
-      new_sheet = RobustExcelOle::Sheet.new(@excel.Activesheet)
+      new_sheet = sheet_class.new(@excel.Activesheet)
       begin
         new_sheet.name = new_sheet_name if new_sheet_name
       rescue WIN32OLERuntimeError => msg
         if msg.message =~ /800A03EC/ 
           raise ExcelErrorSheet, "sheet name already exists"
         else
-          puts "#{msg.message}"
+          t "#{msg.message}"
           raise ExcelErrorSheetUnknown
         end
       end
@@ -583,12 +688,42 @@ module RobustExcelOle
       self.class.bookstore
     end   
 
+    def self.show_books
+      bookstore.books
+    end
+
     def to_s
-      "<#BOOK:" + "#{"not alive " unless alive?}" + "#{File.basename(@stored_filename)}" + " #{@workbook} #{@excel}"  + ">"
+      "#{self.filename}"
     end
 
     def inspect
-      self.to_s
+      "<#Book: " + "#{"not alive " unless alive?}" + "#{File.basename(self.filename) if alive?}" + " #{@workbook} #{@excel}"  + ">"
+    end
+
+    def self.excel_class
+      @excel_class ||= begin
+        module_name = self.parent_name
+        "#{module_name}::Excel".constantize
+      rescue NameError => e
+        Excel
+      end
+    end
+
+    def self.sheet_class
+      @sheet_class ||= begin
+        module_name = self.parent_name
+        "#{module_name}::Sheet".constantize
+      rescue NameError => e
+        Sheet
+      end
+    end
+
+    def excel_class
+      self.class.excel_class
+    end
+
+    def sheet_class
+      self.class.sheet_class
     end
 
   private
@@ -596,10 +731,11 @@ module RobustExcelOle
     def method_missing(name, *args)
       if name.to_s[0,1] =~ /[A-Z]/ 
         begin
+          raise ExcelError, "method missing: workbook not alive" unless alive?
           @workbook.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
@@ -631,9 +767,6 @@ public
   class ExcelErrorSaveUnknown < ExcelErrorSave  # :nodoc: #
   end
 
-  class ExcelErrorNValue < ExcelError  # :nodoc: #
-  end
-
   class ExcelUserCanceled < RuntimeError # :nodoc: #
   end
   
@@ -642,4 +775,5 @@ public
 
   class ExcelErrorSheetUnknown < ExcelErrorSheet    # :nodoc: #
   end
-end
+
+end