robust_excel_ole 0.2.3 → 0.3.0

data/lib/robust_excel_ole/book_store.rb

@@ -0,0 +1,75 @@
+
+# -*- coding: utf-8 -*-
+
+module RobustExcelOle
+
+  class BookStore
+
+    def initialize
+      @filename2books = Hash.new {|hash, key| hash[key] = [] }
+    end
+
+    # returns a book with the given filename, if it was open once
+    # preference order: writable book, readonly unsaved book, readonly book (the last one), closed book
+    # options:  
+    #  :readonly_excel => <instance> -> return the book that was open in the given excel instance, 
+    #                                 even if it is not writable, if such a book exists
+    #                          prefer the writable book as described above, otherwise 
+    def fetch(filename, options = { })
+      filename_key = RobustExcelOle::canonize(filename)
+      readonly_book = readonly_unsaved_book = closed_book = result = nil
+      books = @filename2books[filename_key]
+      return nil unless books
+      books.each do |book|
+        return book if options[:readonly_excel] && book.excel == options[:readonly_excel]
+        if book.alive?
+          if (not book.ReadOnly)
+            if options[:readonly_excel]
+              result = book
+            else
+              return book
+            end
+          else
+            book.Saved ? readonly_book = book : readonly_unsaved_book = book
+          end
+        else
+          closed_book = book
+        end
+      end
+      result ? result : (readonly_unsaved_book ? readonly_unsaved_book : (readonly_book ? readonly_book : closed_book))
+    end
+
+    # stores a book
+    def store(book)
+      filename_key = RobustExcelOle::canonize(book.filename)      
+      if book.stored_filename
+        old_filename_key = RobustExcelOle::canonize(book.stored_filename)
+        @filename2books[old_filename_key].delete(book)
+      end
+      @filename2books[filename_key] |= [book] 
+      book.stored_filename = book.filename
+    end
+
+    # prints the book store
+    def print
+      p "@filename2books:"
+      if @filename2books
+        @filename2books.each do |filename,books|
+          p " filename: #{filename}"
+          p " books:"
+          p " []" if books == []
+          books.each do |book|
+            p "#{book}"
+            p "excel: #{book.excel}"
+            p "alive: #{book.alive?}"
+          end
+        end
+      end
+    end
+
+  end
+
+  class BookStoreError < WIN32OLERuntimeError
+  end
+ 
+end

data/lib/robust_excel_ole/excel.rb

@@ -4,11 +4,11 @@ module RobustExcelOle
 
   class Excel
 
-    attr_writer :ole_app
+    attr_writer :excel
 
-    @@hwnd2app = {}
+    @@hwnd2excel = {}
 
-    # closes all Excel applications
+    # closes all Excel instances
     def self.close_all
       while current_excel do
         close_one_excel
@@ -18,54 +18,48 @@ module RobustExcelOle
       end
     end
 
-    # creates a new Excel application
+    # creates a new Excel instance
     def self.create
       new(:reuse => false)
     end
 
-    # uses the current Excel application (connects), if such a running Excel application exists
+    # uses the current Excel instance (connects), if such a running Excel instance exists
     # creates a new one, otherwise 
     def self.current
       new(:reuse => true)
     end
 
-    # returns an Excel application  
+    # returns an Excel instance  
     # options:
-    #  :reuse          use an already running Excel application (default: true)
-    #  :displayalerts  allow display alerts in Excel            (default: false)
-    #  :visible        make visible in Excel                    (default: false)
+    #  :reuse          use an already running Excel instance (default: true)
+    #  :displayalerts  allow display alerts in Excel         (default: false)
+    #  :visible        make visible in Excel                 (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)
-
-      ole_app = nil
       if options[:reuse] then
-        ole_app = options[:excel] ? options[:excel] : current_excel
-        if ole_app
-          ole_app.DisplayAlerts = options[:displayalerts] unless options[:displayalerts]==nil
-          ole_app.Visible = options[:visible] unless options[:visible]==nil
-        end
+        excel = current_excel
       end
-
-      options = {
-        :displayalerts => false,
-        :visible => false,
-      }.merge(options)
-      unless ole_app
-        ole_app = WIN32OLE.new('Excel.application')
-        ole_app.DisplayAlerts = options[:displayalerts]
-        ole_app.Visible = options[:visible]
+      if not (excel)
+        excel = WIN32OLE.new('Excel.Application')
+        options = {
+          :displayalerts => false,
+          :visible => false,
+        }.merge(options)
       end
+      excel.DisplayAlerts = options[:displayalerts] unless options[:displayalerts].nil?
+      excel.Visible = options[:visible] unless options[:visible].nil?
 
-      hwnd = ole_app.HWnd
-      stored = @@hwnd2app[hwnd]
+      hwnd = excel.HWnd
+      stored = hwnd2excel(hwnd)
 
       if stored 
         result = stored
       else
-        WIN32OLE.const_load(ole_app, RobustExcelOle) unless RobustExcelOle.const_defined?(:CONSTANTS)
+        WIN32OLE.const_load(excel, RobustExcelOle) unless RobustExcelOle.const_defined?(:CONSTANTS)
         result = super(options)
-        result.ole_app = ole_app
-        @@hwnd2app[hwnd] = result
+        result.excel = excel
+        @@hwnd2excel[hwnd] = result
       end
       result
     end
@@ -73,24 +67,73 @@ module RobustExcelOle
     def initialize(options= {}) # :nodoc:
     end
 
-    # returns true, if the Excel applications are identical, false otherwise
+    # generate, save and close an empty workbook
+    def self.generate_workbook file_name
+      excel = create                   
+      excel.Workbooks.Add                           
+      empty_workbook = excel.Workbooks.Item(1)          
+      empty_workbook.SaveAs(file_name, XlExcel8)      
+      empty_workbook.Close                             
+    end
+
+    def self.hwnd2excel(hwnd)
+      @@hwnd2excel[hwnd]
+    end
+
+    def hwnd
+      self.Hwnd
+    end
+
+    # returns true, if the Excel instances are identical, false otherwise
     def == other_excel
-      self.hwnd == other_excel.hwnd    if other_excel.is_a?(Excel)
+      self.Hwnd == other_excel.Hwnd    if other_excel.is_a?(Excel)
     end
 
-    # returns true, if the Excel application is alive, false otherwise
+    # returns true, if the Excel instances is alive, false otherwise
     def alive?
-      @ole_app.Name
+      @excel.Name
       true
     rescue
       puts $!.message
       false
     end
 
+    # set DisplayAlerts in a block
+    def with_displayalerts displayalerts_value
+      old_displayalerts = @excel.DisplayAlerts
+      @excel.DisplayAlerts = displayalerts_value
+      begin
+         yield self
+      ensure
+        @excel.DisplayAlerts = old_displayalerts
+      end
+    end
+
+    # enable DisplayAlerts in the current Excel instance
+    def displayalerts= displayalerts_value
+      @excel.DisplayAlerts = displayalerts_value
+    end
+
+    # return if in the current Excel instance DisplayAlerts is enabled
+    def displayalerts 
+      @excel.DisplayAlerts
+    end
+
+    # make the current Excel instance visible or invisible
+    def visible= visible_value
+      @excel.Visible = visible_value
+    end
+
+    # return if the current Excel instance is visible
+    def visible 
+      @excel.Visible
+    end
+
+
   private
 
-    # closes one Excel application
-    def self.close_one_excel   # :nodoc: #
+    # closes one Excel instance
+    def self.close_one_excel  
       excel = current_excel
       if excel then
         excel.Workbooks.Close
@@ -112,8 +155,8 @@ module RobustExcelOle
           end
         end
 
-        @@hwnd2app[excel_hwnd].die rescue nil
-        #@@hwnd2app[excel_hwnd] = nil
+        hwnd2excel(excel_hwnd).die rescue nil
+        #@@hwnd2excel[excel_hwnd] = nil
       end
 
 
@@ -128,7 +171,7 @@ module RobustExcelOle
     end
 
     # frees all OLE objects in the object space
-    def self.free_all_ole_objects   # :nodoc: #
+    def self.free_all_ole_objects   
       anz_objekte = 0
       ObjectSpace.each_object(WIN32OLE) do |o|
         anz_objekte += 1
@@ -149,7 +192,7 @@ module RobustExcelOle
       puts "went through #{anz_objekte} OLE objects"
     end
 
-    # returns the current Excel application, if a running, working Excel appication exists, nil otherwise
+    # returns the current Excel instance
     def self.current_excel   # :nodoc: #
       result = WIN32OLE.connect('Excel.Application') rescue nil
       if result
@@ -163,26 +206,35 @@ module RobustExcelOle
       result
     end
 
-    def hwnd_xxxx  # :nodoc: #
+    def hwnd_xxxx  
       self.HWnd #rescue Win32 nil
     end
 
-    # set this Excel application to nil
-    def die  # :nodoc:
-      @ole_app = nil
+    # set this Excel instance to nil
+    def die 
+      @excel = nil
     end
 
-    def method_missing(name, *args)  # :nodoc: #
-      @ole_app.send(name, *args)
+
+    def method_missing(name, *args) 
+      if name.to_s[0,1] =~ /[A-Z]/ 
+        begin
+          @excel.send(name, *args)
+        rescue WIN32OLERuntimeError => msg
+          if msg.message =~ /unknown property or method/
+            raise VBAMethodMissingError, "unknown VBA property or method #{name}"
+          else 
+            raise msg
+          end
+        end
+      else  
+        super 
+      end
     end
 
-  end
+  end  
+
+
 
-  def absolute_path(file)
-    file = File.expand_path(file)
-    file = RobustExcelOle::Cygwin.cygpath('-w', file) if RUBY_PLATFORM =~ /cygwin/
-    WIN32OLE.new('Scripting.FileSystemObject').GetAbsolutePathName(file)
-  end
-  module_function :absolute_path
 
 end

data/lib/robust_excel_ole/robustexcelole.sublime-project

@@ -1,8 +1,8 @@
-{
-	"folders":
-	[
-		{
-			"path": "/C/Dokumente und Einstellungen/Zauberthomas/Eigene Dateien/robust_excel_ole"
-		}
-	]
-}
+{
+	"folders":
+	[
+		{
+			"path": "/C/Dokumente und Einstellungen/Zauberthomas/Eigene Dateien/robust_excel_ole"
+		}
+	]
+}

data/lib/robust_excel_ole/sheet.rb

@@ -81,6 +81,25 @@ module RobustExcelOle
       RobustExcelOle::Range.new(@sheet.Range(@sheet.Cells(range.min + 1, col + 1), @sheet.Cells(range.max + 1, col + 1)))
     end
 
+    # returns the contents of a range or cell with given name
+    def nvalue(name)
+      begin
+        item = self.Names.Item(name)
+      rescue WIN32OLERuntimeError
+        raise SheetErrorNValue, "name #{name} not in sheet"  
+      end
+      begin
+        referstorange = item.RefersToRange
+      rescue WIN32OLERuntimeError
+        raise SheetErrorNValue, "range error in sheet"      
+      end
+      begin
+        value = referstorange.Value
+      rescue WIN32OLERuntimeError
+        raise SheetErrorNValue, "value error in sheet" 
+      end
+    end
+
     def method_missing(id, *args)  # :nodoc: #
       @sheet.send(id, *args)
     end
@@ -98,6 +117,15 @@ module RobustExcelOle
       used_last_column = @sheet.UsedRange.Columns.Count
 
       special_last_column >= used_last_column ? special_last_column : used_last_column
-    end
+    end    
   end
+
+  public
+  
+  class SheetError < RuntimeError    # :nodoc: #
+  end
+
+  class SheetErrorNValue < WIN32OLERuntimeError  # :nodoc: #
+  end
+
 end

data/lib/robust_excel_ole/version.rb

@@ -1,3 +1,3 @@
 module RobustExcelOle
-  VERSION = "0.2.3"
+  VERSION = "0.3.0"
 end

data/robust_excel_ole.gemspec

@@ -6,10 +6,10 @@ Gem::Specification.new do |s|
   s.name        = "robust_excel_ole"
   s.version     = RobustExcelOle::VERSION
   s.authors     = ["traths"]
-  s.email       = ["traths@cs.uni-potsdam.de"]
+  s.email       = ["Thomas.Raths@gmx.net"]
   s.homepage    = "https://github.com/Thomas008/robust_excel_ole"
-  s.summary     = "RobustExcelOle is a wrapper library that specializes in the operation of Excel win32ole."
-  s.description = "RobustExcelOle is to wrap the win32ole, and easy to use Excel operations with ruby. Detailed description please see the README."
+  s.summary     = "RobustExcelOle wraps the win32ole library and implements various operations in Excel"
+  s.description = "RobustExcelOle wraps the win32ole library, and allows to perform various operation in Excel with ruby in a reliable way. Detailed description please see the README."
 
   s.rubyforge_project = "robust_excel_ole"
 

data/spec/book_spec.rb

@@ -1,4 +1,3 @@
-
 # -*- coding: utf-8 -*-
 
 require File.join(File.dirname(__FILE__), './spec_helper')
@@ -6,13 +5,15 @@ require File.join(File.dirname(__FILE__), './spec_helper')
 
 $VERBOSE = nil
 
-describe RobustExcelOle::Book do
+include RobustExcelOle
+
+describe Book do
 
   before(:all) do
-    excel = RobustExcelOle::Excel.new(:reuse => true)
+    excel = Excel.new(:reuse => true)
     open_books = excel == nil ? 0 : excel.Workbooks.Count
     puts "*** open books *** : #{open_books}" if open_books > 0
-    RobustExcelOle::Excel.close_all
+    Excel.close_all
   end
 
 
@@ -20,40 +21,90 @@ describe RobustExcelOle::Book do
     @dir = create_tmpdir
     @simple_file = @dir + '/simple.xls'
     @simple_save_file = @dir + '/simple_save.xls'
+    @different_file = @dir + '/different_simple.xls'
+    @simple_file_other_path = @dir + '/more_data/simple.xls'
+    @more_simple_file = @dir + '/more_simple.xls'
   end
 
   after do
-    #RobustExcelOle::Excel.close_all
+    Excel.close_all
     rm_tmp(@dir)
   end
 
 
-  context "class methods" do
-    context "create file" do
+  describe "create file" do
+    context "with standard" do
       it "simple file with default" do
         expect {
-          @book = RobustExcelOle::Book.new(@simple_file)
-          }.to_not raise_error
-        @book.should be_a RobustExcelOle::Book
+          @book = Book.new(@simple_file)
+        }.to_not raise_error
+        @book.should be_a Book
         @book.close
       end
     end
   end
+  
 
   describe "open" do
 
-    context "with non-existing file" do
-      it "should raise an exception" do
-        File.delete @simple_save_file rescue nil
-        expect {
-          RobustExcelOle::Book.open(@simple_save_file)
-        }.to raise_error(ExcelErrorOpen, "file #{@simple_save_file} not found")
+    context "standard use cases" do
+
+      it "should read in a seperate excel instance" do
+        first_excel = Excel.new
+        book = Book.open(@simple_file, :read_only => true, :force_excel => :new)
+        book.should be_a Book
+        book.should be_alive
+        book.ReadOnly.should be_true
+        book.Saved.should be_true
+        book.excel.should_not == first_excel
+        sheet = book[0]
+        sheet[0,0].value.should == "simple"
+        book.close
+      end
+
+      it "should read not bothering about excel instances" do
+        first_excel = Excel.new
+        book = Book.open(@simple_file, :read_only => true)
+        book.should be_a Book
+        book.should be_alive
+        book.ReadOnly.should be_true
+        book.Saved.should be_true
+        book.excel.should == first_excel
+        sheet = book[0]
+        sheet[0,0].value.should == "simple"
+        book.close
+      end
+
+      it "should open writable" do
+        book = Book.open(@simple_file, :if_locked => :take_writable, 
+                                      :if_unsaved => :forget, :if_obstructed => :save)
+        book.close
+      end
+
+      it "should open unobtrusively" do
+        book = Book.open(@simple_file, :if_locked => :take_writable, 
+                                      :if_unsaved => :accept, :if_obstructed => :reuse_excel)
+        book.close
+      end
+
+      it "should open in a given instance" do
+        book1 = Book.open(@simple_file)
+        book2 = Book.open(@simple_file, :force_excel => book1.excel, :if_locked => :force_writable) 
+        book2.close
+        book1.close
+      end
+     
+      it "should open writable" do
+        book = Book.open(@simple_file, :if_locked => :take_writable, 
+                                        :if_unsaved => :save, :if_obstructed => :save)
+        book.close
       end
     end
 
+
     context "with standard options" do
       before do
-        @book = RobustExcelOle::Book.open(@simple_file)
+        @book = Book.open(@simple_file)
       end
 
       after do
@@ -65,48 +116,549 @@ describe RobustExcelOle::Book do
       end
     end
 
-    context "with attr_reader excel" do
+    context "with transperency identity" do
+
       before do
-        @new_book = RobustExcelOle::Book.open(@simple_file)
+        @book = Book.open(@simple_file)
       end
+
       after do
-        @new_book.close
+        @book.close
       end
-      it "should provide the excel application of the book" do
-        excel = @new_book.excel
-        excel.class.should == RobustExcelOle::Excel
-        excel.should be_a RobustExcelOle::Excel
-      end
-    end
-
-    context "with :excel" do
-      it "should reuse the given excel application of the book" do
-        RobustExcelOle::Excel.close_all
-        book1 = RobustExcelOle::Book.open(@simple_file)
-        excel1 = book1.excel
-        book2 = RobustExcelOle::Book.open(@simple_file, :reuse => false)
-        excel2 = book2.excel
-        excel2.should_not == excel1
-        book3 = RobustExcelOle::Book.open(@simple_file)
-        excel3 = book3.excel
-        book4 = RobustExcelOle::Book.open(@simple_file, :excel => excel2)
-        excel4 = book4.excel
-        excel3.should == excel1
-        excel4.should == excel2
-        excel4.class.should == RobustExcelOle::Excel
-        excel4.should be_a RobustExcelOle::Excel
+
+      it "should yield identical Book objects for identical Excel books" do
+        book2 = Book.open(@simple_file)
+        book2.should == @book
+        book2.close
+      end
+
+      it "should yield different Book objects for different Excel books" do
+        book2 = Book.open(@different_file)
+        book2.should_not == @book
+        book2.close
+      end
+
+      it "should yield different Book objects when opened the same file in different Excel instances" do
+        book2 = Book.open(@simple_file, :force_excel => :new)
+        book2.should_not == @book
+        book2.close
+      end
+
+      it "should yield identical Book objects for identical Excel books when reopening" do
+        @book.should be_alive
+        @book.close
+        book2 = Book.open(@simple_file)
+        book2.should == @book
+        book2.should be_alive
+        book2.close
+      end
+    end
+
+    context "with :force_excel" do
+
+      before do
+        @book = Book.open(@simple_file)
+      end
+
+      after do
+        @book.close
+      end
+
+      it "should open in a new Excel" do
+        book2 = Book.open(@simple_file, :force_excel => :new)
+        book2.should be_alive
+        book2.should be_a Book
+        book2.excel.should_not == @book.excel 
+        book2.should_not == @book
+        @book.Readonly.should be_false
+        book2.Readonly.should be_true
+      end
+
+      it "should open in a given Excel" do
+        book2 = Book.open(@simple_file, :force_excel => :new)
+        book2.excel.should_not == @book.excel
+        book3 = Book.open(@simple_file, :force_excel => :new)
+        book3.excel.should_not == book2.excel
+        book3.excel.should_not == @book.excel
+        book2.close
+        book4 = Book.open(@simple_file, :force_excel => book2.excel)
+        book4.should be_alive
+        book4.should be_a Book
+        book4.excel.should == book2.excel
         book4.close
         book3.close
+      end
+
+      it "should do force_excel even if both force_ and default_excel is given" do
+        book2 = Book.open(@simple_file, :default_excel => @book.excel, :force_excel => :new)
+        book2.should be_alive
+        book2.should be_a Book
+        book2.excel.should_not == @book.excel 
+        book2.should_not == @book
+      end
+    end
+
+    context "with :default_excel" do
+
+      before do
+        @book = Book.open(@simple_file)
+      end
+
+      after do
+        @book.close rescue nil
+      end
+
+      it "should reuse an open book" do
+        book2 = Book.open(@simple_file, :default_excel => :reuse)
+        book2.excel.should == @book.excel
+        book2.should be_alive
+        book2.should be_a Book
+        book2.should == @book
         book2.close
-        book1.close
+      end
+
+      it "should reopen a book" do
+        @book.close
+        book2 = Book.open(@simple_file, :default_excel => :reuse)
+        book2.should be_alive
+        book2.should be_a Book
+        book2.excel.should == @book.excel
+        book2.filename.should == @book.filename
+        @book.should be_alive
+        book2.should == @book
+        book2.close
+      end
+
+      it "should connect to the first opened excel, if the book cannot be reopened" do
+        @book.close
+        Excel.close_all
+        excel1 = Excel.new(:reuse => false)
+        excel2 = Excel.new(:reuse => false)
+        book2 = Book.open(@different_file, :default_excel => :reuse)
+        book2.should be_alive
+        book2.should be_a Book
+        book2.excel.should == excel1
+        book2.excel.should_not == excel2
+        book2.close
+      end
+
+      it "should open a new excel, if the book cannot be reopened" do
+        @book.close
+        new_excel = Excel.new(:reuse => false)
+        book2 = Book.open(@different_file, :default_excel => :new)
+        book2.should be_alive
+        book2.should be_a Book
+        book2.excel.should_not == new_excel
+        book2.excel.should_not == @book.excel
+        book2.close
+      end
+
+      it "should open a given excel, if the book cannot be reopened" do
+        @book.close
+        new_excel = Excel.new(:reuse => false)
+        book2 = Book.open(@different_file, :default_excel => @book.excel)
+        book2.should be_alive
+        book2.should be_a Book
+        book2.excel.should_not == new_excel
+        book2.excel.should == @book.excel
+        book2.close
+      end
+
+      it "should reuse an open book by default" do
+        book2 = Book.open(@simple_file)
+        book2.excel.should == @book.excel
+        book2.should == @book
+      end
+
+    end
+
+    context "with :if_locked" do
+
+      context "with an writable book first" do 
+        
+        before do
+          @book = Book.open(@simple_file)
+        end
+
+        after do
+          @book.close
+        end
+        
+        it "should use the already open Excel and book" do
+          @book.ReadOnly.should be_false
+          new_book1 = Book.open(@simple_file, :if_locked => :readonly)
+          new_book1.ReadOnly.should be_true
+          new_book1.excel.should_not == @book.excel
+          new_book1.should_not == @book
+          new_book1.close
+          new_book2 = Book.open(@simple_file, :if_locked => :take_writable)
+          new_book2.ReadOnly.should be_false
+          new_book2.excel == @book.excel
+          new_book2.should == @book
+          new_book2.close
+          new_book3 = Book.open(@simple_file)
+          new_book3.ReadOnly.should be_false
+          new_book3.excel == @book.excel
+          new_book3.should == @book
+          new_book3.close
+        end
+
+        it "should open in a new Excel as read_only" do
+          new_book = Book.open(@simple_file, :force_excel => :new, :if_locked => :readonly)
+          @book.ReadOnly.should be_false
+          new_book.ReadOnly.should be_true
+          new_book.excel.should_not == @book.excel
+          new_book.close
+          new_excel = Excel.new(:reuse => false)
+          new_book2 = Book.open(@simple_file, :force_excel => new_excel, :if_locked => :readonly)
+          new_book2.ReadOnly.should be_true
+          new_book2.excel.should_not == @book.excel
+          new_book2.close
+        end
+
+        it "should open in the Excel where the book is writable" do
+          new_book = Book.open(@simple_file, :force_excel => :new, :if_locked => :take_writable)
+          @book.ReadOnly.should be_false
+          new_book.ReadOnly.should be_false
+          new_book.excel.should == @book.excel
+          new_book.should == @book
+          new_book.close
+          new_excel = Excel.new(:reuse => false)
+          new_book2 = Book.open(@simple_file, :force_excel => new_excel, :if_locked => :take_writable)
+          new_book2.ReadOnly.should be_false
+          new_book2.excel.should == @book.excel
+          new_book2.close
+        end
+
+        it "should open in a new Excel as writable" do
+          new_book = Book.open(@simple_file, :force_excel => :new, :if_locked => :force_writability)
+          @book.ReadOnly.should be_false
+          new_book.ReadOnly.should be_false
+          new_book.excel.should_not == @book.excel
+          new_book.close
+          new_excel = Excel.new(:reuse => false)
+          new_book2 = Book.open(@simple_file, :force_excel => new_excel, :if_locked => :force_writability)
+          new_book2.ReadOnly.should be_false
+          new_book2.excel.should_not == @book.excel
+          new_book2.close
+        end
+
+        it "should open in a new Excel as read_only by default" do
+          new_book = Book.open(@simple_file, :force_excel => :new)
+          @book.ReadOnly.should be_false
+          new_book.ReadOnly.should be_true
+          new_book.excel.should_not == @book.excel
+          new_book.close
+          new_excel = Excel.new(:reuse => false)
+          new_book2 = Book.open(@simple_file, :force_excel => new_excel)
+          new_book2.ReadOnly.should be_true
+          new_book2.excel.should_not == @book.excel
+          new_book2.close
+        end
+      end
+
+      context "with read_only book first" do 
+
+        before do
+          @book = Book.open(@simple_file, :read_only => true)
+        end
+
+        after do
+          @book.close
+        end
+
+        it "should use the already open Excel and book" do
+          @book.ReadOnly.should be_true
+          new_book1 = Book.open(@simple_file, :if_locked => :readonly)
+          new_book1.ReadOnly.should be_true
+          new_book1.excel.should == @book.excel
+          new_book1.should == @book
+          new_book1.close
+          new_book2 = Book.open(@simple_file, :if_locked => :take_writable)
+          new_book2.ReadOnly.should be_true
+          new_book2.excel.should == @book.excel
+          new_book2.should == @book
+          new_book2.close
+          new_book3 = Book.open(@simple_file)
+          new_book3.ReadOnly.should be_true
+          new_book3.excel.should == @book.excel
+          new_book3.should == @book
+          new_book3.close
+        end
+
+        it "should open in the already open Excel" do
+          new_book = Book.open(@simple_file, :if_locked => :force_writability)
+          @book.ReadOnly.should be_true
+          new_book.ReadOnly.should be_false
+          new_book.excel.should_not == @book.excel
+          new_book.should_not == @book
+          new_book.close
+        end
+
+        it "should open in a new Excel as writable" do
+          @book.ReadOnly.should be_true
+          new_book1 = Book.open(@simple_file, :force_excel => :new, :if_locked => :readonly)
+          new_book1.ReadOnly.should be_false
+          new_book1.excel.should_not == @book.excel
+          new_book1.close
+          new_book2 = Book.open(@simple_file, :force_excel => :new, :if_locked => :take_writable)
+          new_book2.ReadOnly.should be_false
+          new_book2.excel.should_not == @book.excel
+          new_book2.close
+          new_book3 = Book.open(@simple_file, :force_excel => :new, :if_locked => :force_writability)
+          new_book3.ReadOnly.should be_false
+          new_book3.excel.should_not == @book.excel
+          new_book3.close
+          new_book4 = Book.open(@simple_file, :force_excel => :new)
+          new_book4.ReadOnly.should be_false
+          new_book4.excel.should_not == @book.excel
+          new_book4.close
+        end
       end
     end
 
+    context "with :if_unsaved" do
+
+      before do
+        @book = Book.open(@simple_file)
+        @sheet = @book[0]
+        @book.add_sheet(@sheet, :as => 'a_name')
+      end
+
+      after do
+        @book.close(:if_unsaved => :forget)
+        @new_book.close rescue nil
+      end
+
+      it "should raise an error, if :if_unsaved is :raise" do
+        expect {
+          @new_book = Book.open(@simple_file, :if_unsaved => :raise)
+        }.to raise_error(ExcelErrorOpen, "book is already open but not saved (#{File.basename(@simple_file)})")
+      end
+
+      it "should let the book open, if :if_unsaved is :accept" do
+        expect {
+          @new_book = Book.open(@simple_file, :if_unsaved => :accept)
+          }.to_not raise_error
+        @book.should be_alive
+        @new_book.should be_alive
+        @new_book.should == @book
+      end
+
+      it "should open book and close old book, if :if_unsaved is :forget" do
+        @new_book = Book.open(@simple_file, :if_unsaved => :forget)
+        @book.should_not be_alive
+        @new_book.should be_alive
+        @new_book.filename.downcase.should == @simple_file.downcase
+      end
+
+      context "with :if_unsaved => :alert" do
+        before do
+         @key_sender = IO.popen  'ruby "' + File.join(File.dirname(__FILE__), '/helpers/key_sender.rb') + '" "Microsoft Office Excel" '  , "w"
+        end
+
+        after do
+          @key_sender.close
+        end
+
+        it "should open the new book and close the unsaved book, if user answers 'yes'" do
+          # "Yes" is the  default. --> language independent
+          @key_sender.puts "{enter}"
+          @new_book = Book.open(@simple_file, :if_unsaved => :alert)
+          @new_book.should be_alive
+          @new_book.filename.downcase.should == @simple_file.downcase
+          @book.should_not be_alive
+        end
+
+        it "should not open the new book and not close the unsaved book, if user answers 'no'" do
+          # "No" is right to "Yes" (the  default). --> language independent
+          # strangely, in the "no" case, the question will sometimes be repeated three times
+          #@book.excel.Visible = true
+          @key_sender.puts "{right}{enter}"
+          @key_sender.puts "{right}{enter}"
+          @key_sender.puts "{right}{enter}"
+          expect{
+            Book.open(@simple_file, :if_unsaved => :alert)
+            }.to raise_error(ExcelUserCanceled, "open: canceled by user")
+          @book.should be_alive
+        end
+      end
+
+      it "should open the book in a new excel instance, if :if_unsaved is :new_excel" do
+        @new_book = Book.open(@simple_file, :if_unsaved => :new_excel)
+        @book.should be_alive
+        @new_book.should be_alive
+        @new_book.filename.should == @book.filename
+        @new_book.excel.should_not == @book.excel       
+        @new_book.close
+      end
+
+      it "should raise an error, if :if_unsaved is default" do
+        expect {
+          @new_book = Book.open(@simple_file)
+        }.to raise_error(ExcelErrorOpen, "book is already open but not saved (#{File.basename(@simple_file)})")
+      end
+
+      it "should raise an error, if :if_unsaved is invalid option" do
+        expect {
+          @new_book = Book.open(@simple_file, :if_unsaved => :invalid_option)
+        }.to raise_error(ExcelErrorOpen, ":if_unsaved: invalid option")
+      end
+    end
+
+    context "with :if_obstructed" do
+
+      for i in 1..2 do
+
+        context "with and without reopen" do
+
+          before do        
+            if i == 1 then 
+              book_before = Book.open(@simple_file)
+              book_before.close
+            end
+            @book = Book.open(@simple_file_other_path)
+            @sheet_count = @book.workbook.Worksheets.Count
+            @sheet = @book[0]
+            @book.add_sheet(@sheet, :as => 'a_name')
+          end
+
+          after do
+            @book.close(:if_unsaved => :forget)
+            @new_book.close rescue nil
+          end
+
+          it "should raise an error, if :if_obstructed is :raise" do
+            expect {
+              @new_book = Book.open(@simple_file, :if_obstructed => :raise)
+            }.to raise_error(ExcelErrorOpen, "blocked by a book with the same name in a different path")
+          end
+
+          it "should close the other book and open the new book, if :if_obstructed is :forget" do
+            @new_book = Book.open(@simple_file, :if_obstructed => :forget)
+            @book.should_not be_alive
+            @new_book.should be_alive
+            @new_book.filename.downcase.should == @simple_file.downcase
+          end
+
+          it "should save the old book, close it, and open the new book, if :if_obstructed is :save" do
+            @new_book = Book.open(@simple_file, :if_obstructed => :save)
+            @book.should_not be_alive
+            @new_book.should be_alive
+            @new_book.filename.downcase.should == @simple_file.downcase
+            old_book = Book.open(@simple_file_other_path, :if_obstructed => :forget)
+            old_book.workbook.Worksheets.Count.should ==  @sheet_count + 1
+            old_book.close
+          end
+
+          it "should raise an error, if the old book is unsaved, and close the old book and open the new book, 
+              if :if_obstructed is :close_if_saved" do
+            expect{
+              @new_book = Book.open(@simple_file, :if_obstructed => :close_if_saved)
+            }.to raise_error(ExcelErrorOpen, "book with the same name in a different path is unsaved")
+            @book.save
+            @new_book = Book.open(@simple_file, :if_obstructed => :close_if_saved)
+            @book.should_not be_alive
+            @new_book.should be_alive
+            @new_book.filename.downcase.should == @simple_file.downcase
+            old_book = Book.open(@simple_file_other_path, :if_obstructed => :forget)
+            old_book.workbook.Worksheets.Count.should ==  @sheet_count + 1
+            old_book.close
+          end
+
+          it "should open the book in a new excel instance, if :if_obstructed is :new_excel" do
+            @new_book = Book.open(@simple_file, :if_obstructed => :new_excel)
+            @book.should be_alive
+            @new_book.should be_alive
+            @new_book.filename.should_not == @book.filename
+            @new_book.excel.should_not == @book.excel
+          end
+
+          it "should raise an error, if :if_obstructed is default" do
+            expect {
+              @new_book = Book.open(@simple_file)
+            }.to raise_error(ExcelErrorOpen, "blocked by a book with the same name in a different path")
+          end
+
+          it "should raise an error, if :if_obstructed is invalid option" do
+            expect {
+              @new_book = Book.open(@simple_file, :if_obstructed => :invalid_option)
+            }.to raise_error(ExcelErrorOpen, ":if_obstructed: invalid option")
+          end
+        end
+      end
+    end
+
+    context "with an already saved book" do
+      before do
+        @book = Book.open(@simple_file)
+      end
+
+      after do
+        @book.close
+      end
+
+      possible_options = [:read_only, :raise, :accept, :forget, nil]
+      possible_options.each do |options_value|
+        context "with :if_unsaved => #{options_value} and in the same and different path" do
+          before do
+            @new_book = Book.open(@simple_file, :reuse=> true, :if_unsaved => options_value)
+            @different_book = Book.new(@different_file, :reuse=> true, :if_unsaved => options_value)
+          end
+          after do
+            @new_book.close
+            @different_book.close
+          end
+          it "should open without problems " do
+            @new_book.should be_a Book
+            @different_book.should be_a Book
+          end
+          it "should belong to the same Excel instance" do
+            @new_book.excel.should == @book.excel
+            @different_book.excel.should == @book.excel
+          end
+        end
+      end
+    end      
+    
+
+    context "with non-existing file" do
+      it "should raise an exception" do
+        File.delete @simple_save_file rescue nil
+        expect {
+          Book.open(@simple_save_file)
+        }.to raise_error(ExcelErrorOpen, "file #{@simple_save_file} not found")
+      end
+    end
+
+    context "with attr_reader excel" do
+      before do
+        @new_book = Book.open(@simple_file)
+      end
+      after do
+        @new_book.close
+      end
+      it "should provide the excel instance of the book" do
+        excel = @new_book.excel
+        excel.class.should == Excel
+        excel.should be_a Excel
+      end
+    end
 
     context "with :read_only" do
+      
+      it "should open the second book in another Excel as writable" do
+        book = Book.open(@simple_file, :read_only => true)
+        book.ReadOnly.should be_true
+        new_book = Book.open(@simple_file, :force_excel => :new, :read_only => false)
+        new_book.ReadOnly.should be_false
+        new_book.close
+        book.close
+      end
+
       it "should be able to save, if :read_only => false" do
-        book = RobustExcelOle::Book.open(@simple_file, :read_only => false)
-        book.should be_a RobustExcelOle::Book
+        book = Book.open(@simple_file, :read_only => false)
+        book.should be_a Book
         expect {
           book.save_as(@simple_save_file, :if_exists => :overwrite)
         }.to_not raise_error
@@ -114,8 +666,8 @@ describe RobustExcelOle::Book do
       end
 
       it "should be able to save, if :read_only is set to default value" do
-        book = RobustExcelOle::Book.open(@simple_file)
-        book.should be_a RobustExcelOle::Book
+        book = Book.open(@simple_file)
+        book.should be_a Book
         expect {
           book.save_as(@simple_save_file, :if_exists => :overwrite)
         }.to_not raise_error
@@ -123,8 +675,8 @@ describe RobustExcelOle::Book do
       end
 
       it "should raise an error, if :read_only => true" do
-        book = RobustExcelOle::Book.open(@simple_file, :read_only => true)
-        book.should be_a RobustExcelOle::Book
+        book = Book.open(@simple_file, :read_only => true)
+        book.should be_a Book
         expect {
           book.save_as(@simple_save_file, :if_exists => :overwrite)
         }.to raise_error
@@ -133,9 +685,9 @@ describe RobustExcelOle::Book do
     end
 
     context "with block" do
-      it 'block parameter should be instance of RobustExcelOle::Book' do
-        RobustExcelOle::Book.open(@simple_file) do |book|
-          book.should be_a RobustExcelOle::Book
+      it 'block parameter should be instance of Book' do
+        Book.open(@simple_file) do |book|
+          book.should be_a Book
         end
       end
     end
@@ -145,219 +697,413 @@ describe RobustExcelOle::Book do
         path = '~/Abrakadabra.xlsx'
         expected_path = Regexp.new(File.expand_path(path).gsub(/\//, "."))
         expect {
-          RobustExcelOle::Book.open(path)
+          Book.open(path)
         }.to raise_error(ExcelErrorOpen, "file #{path} not found")
       end
     end
+  end
 
-    context "with an already opened book" do
+  describe "send methods to workbook" do
 
+    context "with standard" do
       before do
-        @book = RobustExcelOle::Book.open(@simple_file)
+        @book = Book.open(@simple_file)
       end
 
       after do
         @book.close
       end
 
-      context "with an already saved book" do
-        possible_options = [:read_only, :raise, :accept, :forget, nil]
-        possible_options.each do |options_value|
-          context "with :if_unsaved => #{options_value} and in the same and different path" do
-            before do
-              @new_book = RobustExcelOle::Book.open(@simple_file, :reuse=> true, :if_unsaved => options_value)
-              different_file = @dir + '/different_simple.xls'
-              @different_book = RobustExcelOle::Book.new(different_file, :reuse=> true, :if_unsaved => options_value)
-            end
-            after do
-              @new_book.close
-              @different_book.close
-            end
-            it "should open without problems " do
-              @new_book.should be_a RobustExcelOle::Book
-              @different_book.should be_a RobustExcelOle::Book
-            end
-            it "should belong to the same Excel application" do
-              @new_book.excel.should == @book.excel
-              @different_book.excel.should == @book.excel
-            end
-          end
-        end
+      it "should send Saved to workbook" do
+        @book.Saved.should be_true
       end
 
-      context "with an unsaved book" do
+      it "should send Fullname to workbook" do
+        @book.Fullname.tr('\\','/').should == @simple_file
+      end
+    end
+  end
 
-        before do
-          @book = RobustExcelOle::Book.open(@simple_file)
-          @sheet = @book[0]
-          @book.add_sheet(@sheet, :as => 'a_name')
-        end
+  describe "unobtrusively" do
 
-        after do
-          @book.close(:if_unsaved => :forget)
-          @new_book.close rescue nil
-        end
+    def unobtrusively_ok? # :nodoc: #
+      Book.unobtrusively(@simple_file) do |book|
+        book.should be_a Book
+        sheet = book[0]
+        sheet[0,0] = sheet[0,0].value == "simple" ? "complex" : "simple"
+        book.should be_alive
+        book.Saved.should be_false
+      end
+    end
 
-        it "should raise an error, if :if_unsaved is :raise" do
-          expect {
-            @new_book = RobustExcelOle::Book.open(@simple_file, :if_unsaved => :raise)
-          }.to raise_error(ExcelErrorOpen, "book is already open but not saved (#{File.basename(@simple_file)})")
-        end
+    context "with an open book" do
 
-        it "should let the book open, if :if_unsaved is :accept" do
-          expect {
-            @new_book = RobustExcelOle::Book.open(@simple_file, :if_unsaved => :accept)
-            }.to_not raise_error
-          @book.should be_alive
-          @new_book.should be_alive
-          @new_book.should == @book
-        end
+      before do
+        @book = Book.open(@simple_file)
+      end
 
-        it "should open book and close old book, if :if_unsaved is :forget" do
-          @new_book = RobustExcelOle::Book.open(@simple_file, :if_unsaved => :forget)
-          @book.should_not be_alive
-          @new_book.should be_alive
-          @new_book.filename.downcase.should == @simple_file.downcase
-        end
+      after do
+        @book.close(:if_unsaved => :forget)
+      end
 
-        context "with :if_unsaved => :alert" do
-          before do
-           @key_sender = IO.popen  'ruby "' + File.join(File.dirname(__FILE__), '/helpers/key_sender.rb') + '" "Microsoft Office Excel" '  , "w"
-          end
+      it "should let a saved book saved" do
+        @book.Saved.should be_true
+        @book.should be_alive
+        sheet = @book[0]
+        old_cell_value = sheet[0,0].value
+        unobtrusively_ok?
+        @book.Saved.should be_true
+        @book.should be_alive
+        sheet = @book[0]
+        sheet[0,0].value.should_not == old_cell_value
+      end
 
-          after do
-            @key_sender.close
-          end
+      it "should let an unsaved book unsaved" do
+        sheet = @book[0]
+        sheet[0,0] = sheet[0,0].value == "simple" ? "complex" : "simple" 
+        @book.Saved.should be_false
+        @book.should be_alive
+        old_cell_value = sheet[0,0].value
+        unobtrusively_ok?
+        @book.Saved.should be_false
+        @book.should be_alive
+        sheet = @book[0]
+        sheet[0,0].value.should_not == old_cell_value
+      end
+    end
+    
+    context "with a closed book" do
+      
+      before do
+        @book = Book.open(@simple_file)
+      end
 
-          it "should open the new book and close the unsaved book, if user answers 'yes'" do
-            # "Yes" is the  default. --> language independent
-            @key_sender.puts "{enter}"
-            @new_book = RobustExcelOle::Book.open(@simple_file, :if_unsaved => :alert)
-            @book.should_not be_alive
-            @new_book.should be_alive
-            @new_book.filename.downcase.should == @simple_file.downcase
-          end
+      after do
+        @book.close(:if_unsaved => :forget) 
+        Excel.close_all
+      end
 
-          it "should not open the new book and not close the unsaved book, if user answers 'no'" do
-            # "No" is right to "Yes" (the  default). --> language independent
-            # strangely, in the "no" case, the question will sometimes be repeated three times
-            #@book.excel.Visible = true
-            @key_sender.puts "{right}{enter}"
-            @key_sender.puts "{right}{enter}"
-            @key_sender.puts "{right}{enter}"
-            expect{
-              RobustExcelOle::Book.open(@simple_file, :if_unsaved => :alert)
-              }.to raise_error(ExcelUserCanceled, "open: canceled by user")
-            @book.should be_alive
-          end
-        end
+      it "should let the closed book closed by default" do
+        sheet = @book[0]
+        old_cell_value = sheet[0,0].value
+        @book.close
+        @book.should_not be_alive
+        unobtrusively_ok?
+        @book.should_not be_alive
+        @book = Book.open(@simple_file)
+        sheet = @book[0]
+        sheet[0,0].value.should_not == old_cell_value
+      end
 
-        it "should open the book in a new excel application, if :if_unsaved is :new_app" do
-          @new_book = RobustExcelOle::Book.open(@simple_file, :if_unsaved => :new_app)
-          @book.should be_alive
-          @new_book.should be_alive
-          @new_book.filename.should == @book.filename
-          @new_book.excel.should_not == @book.excel
-          @new_book.close
+      # The bold reanimation of the @book
+      it "should keep open the book" do
+        sheet = @book[0]
+        old_cell_value = sheet[0,0].value
+        @book.close
+        @book.should_not be_alive
+        Book.unobtrusively(@simple_file, :keep_open => true) do |book|
+          book.should be_a Book
+          sheet = book[0]
+          cell = sheet[0,0]
+          sheet[0,0] = cell.value == "simple" ? "complex" : "simple"
+          book.Saved.should be_false
         end
+        @book.should be_alive
+        @book.close
+        @book = Book.open(@simple_file)
+        sheet = @book[0]
+        sheet[0,0].value.should_not == old_cell_value
+      end
+    end
 
-        it "should raise an error, if :if_unsaved is default" do
-          expect {
-            @new_book = RobustExcelOle::Book.open(@simple_file)
-          }.to raise_error(ExcelErrorOpen, "book is already open but not saved (#{File.basename(@simple_file)})")
-        end
+    context "with two books" do
 
-        it "should raise an error, if :if_unsaved is invalid option" do
-          expect {
-            @new_book = RobustExcelOle::Book.open(@simple_file, :if_unsaved => :invalid_option)
-          }.to raise_error(ExcelErrorOpen, ":if_unsaved: invalid option")
+      before do
+        @book = Book.open(@simple_file)
+      end
+
+      after do
+        @book.close(:if_unsaved => :forget)
+        @book2.close(:if_unsaved => :forget)
+      end
+
+      it "should let the unsaved book unsaved" do
+        sheet = @book[0]
+        old_cell_value = sheet[0,0].value
+        sheet[0,0] = sheet[0,0].value == "simple" ? "complex" : "simple"
+        old_cell_value = sheet[0,0].value
+        @book.Saved.should be_false
+        unobtrusively_ok?
+        @book.should be_alive
+        @book.Saved.should be_false
+        @book.close(:if_unsaved => :forget)
+        @book2 = Book.open(@simple_file)
+        sheet2 = @book2[0]
+        sheet2[0,0].value.should_not == old_cell_value
+      end
+
+      it "should modify unobtrusively the second, writable book" do
+        @book2 = Book.open(@simple_file, :force_excel => :new)
+        @book.ReadOnly.should be_false
+        @book2.ReadOnly.should be_true
+        sheet = @book2[0]
+        old_cell_value = sheet[0,0].value
+        sheet[0,0] = sheet[0,0].value == "simple" ? "complex" : "simple"
+        unobtrusively_ok?
+        @book2.should be_alive
+        @book2.Saved.should be_false
+        @book2.close(:if_unsaved => :forget)
+        @book.close
+        @book = Book.open(@simple_file)
+        sheet2 = @book[0]
+        sheet2[0,0].value.should_not == old_cell_value
+      end
+    end    
+
+    context "with read_only book" do
+
+      before do
+        @book = Book.open(@simple_file, :read_only => true)
+      end
+
+      after do
+        @book.close
+      end
+
+      it "should let the saved book saved" do
+        @book.ReadOnly.should be_true
+        @book.Saved.should be_true
+        sheet = @book[0]
+        old_cell_value = sheet[0,0].value
+        unobtrusively_ok?
+        @book.should be_alive
+        @book.Saved.should be_true
+        @book.ReadOnly.should be_true
+        @book.close
+        book2 = Book.open(@simple_file)
+        sheet2 = book2[0]
+        sheet2[0,0].value.should_not == old_cell_value
+      end
+
+      it "should let the unsaved book unsaved" do
+        @book.ReadOnly.should be_true
+        sheet = @book[0]
+        sheet[0,0] = sheet[0,0].value == "simple" ? "complex" : "simple" 
+        @book.Saved.should be_false
+        @book.should be_alive
+        cell_value = sheet[0,0].value
+        unobtrusively_ok?
+        @book.should be_alive
+        @book.Saved.should be_false
+        @book.ReadOnly.should be_true
+        @book.close
+        book2 = Book.open(@simple_file)
+        sheet2 = book2[0]
+        # modifies unobtrusively the saved version, not the unsaved version
+        sheet2[0,0].value.should == cell_value        
+      end
+    end
+
+    context "with a virgin Book class" do
+      before do
+        class Book
+          @@bookstore = nil
         end
+      end
+      it "should work" do
+        expect{ unobtrusively_ok? }.to_not raise_error
+      end
+    end
 
+    context "with a book never opened before" do
+      before do
+        class Book
+          @@bookstore = nil
+        end
+        other_book = Book.open(@different_file)
+      end
+      it "should open the book" do
+        expect{ unobtrusively_ok? }.to_not raise_error
       end
     end
 
-    context "with a book in a different path" do
+    context "with a saved book" do
 
       before do
-        @simple_file_other_path = @dir + '/more_data/simple.xls'
-        @book = RobustExcelOle::Book.open(@simple_file_other_path)
-        @sheet_count = @book.workbook.Worksheets.Count
-        @sheet = @book[0]
-        @book.add_sheet(@sheet, :as => 'a_name')
+        @book1 = Book.open(@simple_file)
       end
 
       after do
-        @book.close(:if_unsaved => :forget)
-        @new_book.close rescue nil
+        @book1.close(:if_unsaved => :forget)
+      end
+
+      it "should save if the book was modified during unobtrusively" do
+        m_time = File.mtime(@book1.stored_filename)
+        Book.unobtrusively(@simple_file) do |book|
+          @book1.Saved.should be_true
+          book.Saved.should be_true  
+          sheet = book[0]
+          cell = sheet[0,0]
+          sheet[0,0] = cell.value == "simple" ? "complex" : "simple"
+          @book1.Saved.should be_false
+          book.Saved.should be_false
+          sleep 1
+        end
+        m_time2 = File.mtime(@book1.stored_filename)
+        m_time2.should_not == m_time
+      end      
+
+      it "should not save the book was not modified during unobtrusively" do
+        m_time = File.mtime(@book1.stored_filename)
+        Book.unobtrusively(@simple_file) do |book|
+          @book1.Saved.should be_true
+          book.Saved.should be_true 
+          sleep 1
+        end
+        m_time2 = File.mtime(@book1.stored_filename)
+        m_time2.should == m_time
+      end            
+    end
+
+    context "with block result" do
+      before do
+        @book1 = Book.open(@simple_file)
       end
 
-      it "should raise an error, if :if_obstructed is :raise" do
-        expect {
-          @new_book = RobustExcelOle::Book.open(@simple_file, :if_obstructed => :raise)
-        }.to raise_error(ExcelErrorOpen, "blocked by a book with the same name in a different path")
+      after do
+        @book1.close(:if_unsaved => :forget)
+      end      
+
+      it "should yield the block result true" do
+        result = 
+          Book.unobtrusively(@simple_file) do |book| 
+            @book1.Saved.should be_true
+          end
+        result.should == true
       end
 
-      it "should close the other book and open the new book, if :if_obstructed is :forget" do
-        @new_book = RobustExcelOle::Book.open(@simple_file, :if_obstructed => :forget)
-        @book.should_not be_alive
-        @new_book.should be_alive
-        @new_book.filename.downcase.should == @simple_file.downcase
+      it "should yield the block result nil" do
+        result = 
+          Book.unobtrusively(@simple_file) do |book| 
+          end
+        result.should == nil
       end
 
-      it "should save the old book, close it, and open the new book, if :if_obstructed is :save" do
-        @new_book = RobustExcelOle::Book.open(@simple_file, :if_obstructed => :save)
-        @book.should_not be_alive
-        @new_book.should be_alive
-        @new_book.filename.downcase.should == @simple_file.downcase
-        old_book = RobustExcelOle::Book.open(@simple_file_other_path, :if_obstructed => :forget)
-        old_book.workbook.Worksheets.Count.should ==  @sheet_count + 1
-        old_book.close
+      it "should yield the block result with an unmodified book" do
+        sheet1 = @book1[0]
+        cell1 = sheet1[0,0].value
+        result = 
+          Book.unobtrusively(@simple_file) do |book| 
+            sheet = book[0]
+            cell = sheet[0,0].value
+          end
+        result.should == cell1
+      end
+
+      it "should yield the block result even if the book gets saved" do
+        sheet1 = @book1[0]
+        @book1.save
+        result = 
+          Book.unobtrusively(@simple_file) do |book| 
+            sheet = book[0]
+            sheet[0,0].value = 22
+            @book1.Saved.should be_false
+            42
+          end
+        result.should == 42
+        @book1.Saved.should be_true
       end
+    end
 
-      it "should raise an error, if the old book is unsaved, and close the old book and open the new book, 
-          if :if_obstructed is :close_if_saved" do
-        expect{
-          @new_book = RobustExcelOle::Book.open(@simple_file, :if_obstructed => :close_if_saved)
-        }.to raise_error(ExcelErrorOpen, "book with the same name in a different path is unsaved")
-        @book.save
-        @new_book = RobustExcelOle::Book.open(@simple_file, :if_obstructed => :close_if_saved)
-        @book.should_not be_alive
-        @new_book.should be_alive
-        @new_book.filename.downcase.should == @simple_file.downcase
-        old_book = RobustExcelOle::Book.open(@simple_file_other_path, :if_obstructed => :forget)
-        old_book.workbook.Worksheets.Count.should ==  @sheet_count + 1
-        old_book.close
+    context "with visible" do
+       before do
+        @book1 = Book.open(@simple_file)
       end
 
-      it "should open the book in a new excel application, if :if_obstructed is :new_app" do
-        @new_book = RobustExcelOle::Book.open(@simple_file, :if_obstructed => :new_app)
-        @book.should be_alive
-        @new_book.should be_alive
-        @new_book.filename.should_not == @book.filename
-        @new_book.excel.should_not == @book.excel
+      after do
+        @book1.close(:if_unsaved => :forget)
+      end    
+
+      it "should unobtrusively use a book invisibe" do
+        @book1.excel.Visible.should be_false
+        Book.unobtrusively(@simple_file, :visible => false) do |book| 
+          @book1.excel.Visible.should be_false
+          book.excel.Visible.should be_false
+          sheet = book[0]
+          cell = sheet[0,0]
+          sheet[0,0] = cell.value == "simple" ? "complex" : "simple"
+          sheet = book[0]
+        end
+        @book1.excel.Visible.should be_false
+      end
+      
+      it "should unobtrusively use a book visibe" do
+        @book1.excel.Visible.should be_false
+        Book.unobtrusively(@simple_file, :visible => true) do |book| 
+          @book1.excel.Visible.should be_true
+          book.excel.Visible.should be_true
+          sheet = book[0]
+          cell = sheet[0,0]
+          sheet[0,0] = cell.value == "simple" ? "complex" : "simple"
+          sheet = book[0]
+        end
+        @book1.excel.Visible.should be_false
+      end
+
+      it "should unobtrusively use a book invisibe by default" do
+        @book1.excel.Visible.should be_false
+        Book.unobtrusively(@simple_file) do |book| 
+          @book1.excel.Visible.should be_false
+          book.excel.Visible.should be_false
+          sheet = book[0]
+          cell = sheet[0,0]
+          sheet[0,0] = cell.value == "simple" ? "complex" : "simple"
+          sheet = book[0]
+        end
+        @book1.excel.Visible.should be_false
       end
+    end
+  end
+
+  describe "nvalue" do
+    context "with standard" do
+      before do
+        @book1 = Book.open(@more_simple_file)
+      end
+
+      after do
+        @book1.close
+      end   
 
-      it "should raise an error, if :if_obstructed is default" do
+      it "should return value of a range" do
+        @book1.nvalue("new").should == "foo"
+        @book1.nvalue("one").should == 1
+        @book1.nvalue("firstrow").should == [[1,2]]        
+        @book1.nvalue("four").should == [[1,2],[3,4]]
+        @book1.nvalue("firstrow").should_not == "12"
+      end
+
+      it "should raise an error if name not defined" do
         expect {
-          @new_book = RobustExcelOle::Book.open(@simple_file)
-        }.to raise_error(ExcelErrorOpen, "blocked by a book with the same name in a different path")
+          value = @book1.nvalue("foo")
+        }.to raise_error(ExcelErrorNValue, "name foo not in more_simple.xls")
       end
 
-      it "should raise an error, if :if_obstructed is invalid option" do
+      it "should raise an error if name was defined but contents is calcuated" do
         expect {
-          @new_book = RobustExcelOle::Book.open(@simple_file, :if_obstructed => :invalid_option)
-        }.to raise_error(ExcelErrorOpen, ":if_obstructed: invalid option")
+          value = @book1.nvalue("named_formula")
+        }.to raise_error(ExcelErrorNValue, "range error in more_simple.xls")
       end
 
+
     end
   end
 
-
   describe "close" do
 
     context "with saved book" do
       before do
-        @book = RobustExcelOle::Book.open(@simple_file)
+        @book = Book.open(@simple_file)
       end
 
       it "should close book" do
@@ -368,9 +1114,9 @@ describe RobustExcelOle::Book do
       end
     end
 
-    context "with unsaved book and with :read_only" do
+    context "with unsaved read_only book" do
       before do
-        @book = RobustExcelOle::Book.open(@simple_file, :read_only => true)
+        @book = Book.open(@simple_file, :read_only => true)
         @sheet_count = @book.workbook.Worksheets.Count
         @book.add_sheet(@sheet, :as => 'a_name')
       end
@@ -379,7 +1125,7 @@ describe RobustExcelOle::Book do
         expect{
           @book.close
           }.to_not raise_error
-        new_book = RobustExcelOle::Book.open(@simple_file)
+        new_book = Book.open(@simple_file)
         new_book.workbook.Worksheets.Count.should ==  @sheet_count
         new_book.close
       end
@@ -388,7 +1134,7 @@ describe RobustExcelOle::Book do
 
     context "with unsaved book" do
       before do
-        @book = RobustExcelOle::Book.open(@simple_file)
+        @book = Book.open(@simple_file)
         @sheet_count = @book.workbook.Worksheets.Count
         @book.add_sheet(@sheet, :as => 'a_name')
         @sheet = @book[0]
@@ -414,7 +1160,7 @@ describe RobustExcelOle::Book do
         @book.should_not be_alive
         expect{
           ole_workbook.Name}.to raise_error(WIN32OLERuntimeError)
-        new_book = RobustExcelOle::Book.open(@simple_file)
+        new_book = Book.open(@simple_file)
         begin
           new_book.workbook.Worksheets.Count.should ==  @sheet_count
         ensure
@@ -432,7 +1178,7 @@ describe RobustExcelOle::Book do
         @book.should_not be_alive
         expect{
           ole_workbook.Name}.to raise_error(WIN32OLERuntimeError)
-        new_book = RobustExcelOle::Book.open(@simple_file)
+        new_book = Book.open(@simple_file)
         begin
           new_book.workbook.Worksheets.Count.should == @sheet_count + 1
         ensure
@@ -472,7 +1218,7 @@ describe RobustExcelOle::Book do
               @book.should_not be_alive
               expect{ole_workbook.Name}.to raise_error(WIN32OLERuntimeError)
             end
-            new_book = RobustExcelOle::Book.open(@simple_file, :if_unsaved => :forget)
+            new_book = Book.open(@simple_file, :if_unsaved => :forget)
             begin
               new_book.workbook.Worksheets.Count.should == @sheet_count + (answer==:yes ? 1 : 0)
               new_book.excel.DisplayAlerts.should == displayalert_value
@@ -501,7 +1247,7 @@ describe RobustExcelOle::Book do
 
     context "with simple save" do
       it "should save for a file opened without :read_only" do
-        @book = RobustExcelOle::Book.open(@simple_file)
+        @book = Book.open(@simple_file)
         @book.add_sheet(@sheet, :as => 'a_name')
         @new_sheet_count = @book.workbook.Worksheets.Count
         expect {
@@ -512,7 +1258,7 @@ describe RobustExcelOle::Book do
       end
 
       it "should raise error with read_only" do
-        @book = RobustExcelOle::Book.open(@simple_file, :read_only => true)
+        @book = Book.open(@simple_file, :read_only => true)
         expect {
           @book.save
         }.to raise_error(ExcelErrorSave, "Not opened for writing (opened with :read_only option)")
@@ -522,7 +1268,7 @@ describe RobustExcelOle::Book do
 
     context "with open with read only" do
       before do
-        @book = RobustExcelOle::Book.open(@simple_file, :read_only => true)
+        @book = Book.open(@simple_file, :read_only => true)
       end
 
       after do
@@ -539,7 +1285,7 @@ describe RobustExcelOle::Book do
 
     context "with argument" do
       before do
-        RobustExcelOle::Book.open(@simple_file) do |book|
+        Book.open(@simple_file) do |book|
           book.save_as(@simple_save_file, :if_exists => :overwrite)
         end
       end
@@ -551,7 +1297,7 @@ describe RobustExcelOle::Book do
 
     context "with different extensions" do
       before do
-        @book = RobustExcelOle::Book.open(@simple_file)
+        @book = Book.open(@simple_file)
       end
 
       after do
@@ -565,8 +1311,8 @@ describe RobustExcelOle::Book do
           File.delete simple_save_file rescue nil
           @book.save_as(simple_save_file, :if_exists => :overwrite)
           File.exist?(simple_save_file).should be_true
-          new_book = RobustExcelOle::Book.open(simple_save_file)
-          new_book.should be_a RobustExcelOle::Book
+          new_book = Book.open(simple_save_file)
+          new_book.should be_a Book
           new_book.close
         end
       end
@@ -577,7 +1323,7 @@ describe RobustExcelOle::Book do
     possible_displayalerts.each do |displayalert_value|
       context "with displayalerts=#{displayalert_value}" do
         before do
-          @book = RobustExcelOle::Book.open(@simple_file, :displayalerts => displayalert_value)
+          @book = Book.open(@simple_file, :displayalerts => displayalert_value)
         end
 
         after do
@@ -587,7 +1333,7 @@ describe RobustExcelOle::Book do
         it "should raise an error if the book is open" do
           File.delete @simple_save_file rescue nil
           FileUtils.copy @simple_file, @simple_save_file
-          book_save = RobustExcelOle::Book.open(@simple_save_file, :reuse => false)
+          book_save = Book.open(@simple_save_file, :excel => :new)
           expect{
             @book.save_as(@simple_save_file, :if_exists => :overwrite)
             }.to raise_error(ExcelErrorSave, "book is open and used in Excel")
@@ -601,11 +1347,10 @@ describe RobustExcelOle::Book do
           end
           @book.save_as(@simple_save_file, :if_exists => :overwrite)
           File.exist?(@simple_save_file).should be_true
-          new_book = RobustExcelOle::Book.open(@simple_save_file)
-          new_book.should be_a RobustExcelOle::Book
+          new_book = Book.open(@simple_save_file)
+          new_book.should be_a Book
           new_book.close
         end
-
         it "should save to 'simple_save_file.xls' with :if_exists => :raise" do
           dirname, basename = File.split(@simple_save_file)
           File.delete @simple_save_file rescue nil
@@ -618,7 +1363,7 @@ describe RobustExcelOle::Book do
             @book.save_as(@simple_save_file, :if_exists => :raise)
             }.to raise_error(ExcelErrorSave, 'book already exists: ' + basename)
           File.exist?(@simple_save_file).should be_true
-          (File.size?(@simple_save_file) == booklength).should be_true
+          File.size?(@simple_save_file).should == booklength
         end
 
         context "with :if_exists => :alert" do
@@ -641,10 +1386,11 @@ describe RobustExcelOle::Book do
             @book.save_as(@simple_save_file, :if_exists => :alert)
             File.exist?(@simple_save_file).should be_true
             File.size?(@simple_save_file).should > @garbage_length
-            new_book = RobustExcelOle::Book.open(@simple_save_file)
-            new_book.should be_a RobustExcelOle::Book
             @book.excel.DisplayAlerts.should == displayalert_value
+            new_book = Book.open(@simple_save_file, :excel => :new)
+            new_book.should be_a Book
             new_book.close
+            @book.excel.DisplayAlerts.should == displayalert_value
           end
 
           it "should not save if user answers 'no'" do
@@ -702,7 +1448,7 @@ describe RobustExcelOle::Book do
             @book.save_as(@simple_save_file)
             }.to raise_error(ExcelErrorSave, 'book already exists: ' + basename)
           File.exist?(@simple_save_file).should be_true
-          (File.size?(@simple_save_file) == booklength).should be_true
+          File.size?(@simple_save_file).should == booklength
         end
 
         it "should save to 'simple_save_file.xls' with :if_exists => :invalid_option" do
@@ -716,12 +1462,12 @@ describe RobustExcelOle::Book do
     end
   end
 
-  describe "== , alive?, filename" do
+  describe "== , alive?, filename, visible, empty_workbook" do
 
     context "with alive?" do
 
       before do
-        @book = RobustExcelOle::Book.open(@simple_file)
+        @book = Book.open(@simple_file)
       end
 
       after do
@@ -742,7 +1488,7 @@ describe RobustExcelOle::Book do
     context "with filename" do
 
       before do
-        @book = RobustExcelOle::Book.open(@simple_file)
+        @book = Book.open(@simple_file)
       end
 
       after do
@@ -763,7 +1509,7 @@ describe RobustExcelOle::Book do
     context "with ==" do
 
       before do
-        @book = RobustExcelOle::Book.open(@simple_file)
+        @book = Book.open(@simple_file)
       end
 
       after do
@@ -772,24 +1518,22 @@ describe RobustExcelOle::Book do
       end
 
       it "should be true with two identical books" do
-        @new_book = RobustExcelOle::Book.open(@simple_file)
+        @new_book = Book.open(@simple_file)
         @new_book.should == @book
       end
 
       it "should be false with two different books" do
-        different_file = @dir + '/different_simple.xls'
-        @new_book = RobustExcelOle::Book.new(different_file)
+        @new_book = Book.new(@different_file)
         @new_book.should_not == @book
       end
 
-      it "should be false with same book names but different paths" do
-        simple_file_other_path = @dir + '/more_data/simple.xls'
-        @new_book = RobustExcelOle::Book.new(simple_file_other_path, :reuse => false)
+      it "should be false with same book names but different paths" do       
+        @new_book = Book.new(@simple_file_other_path, :excel => :new)
         @new_book.should_not == @book
       end
 
-      it "should be false with same book names but different excel apps" do
-        @new_book = RobustExcelOle::Book.new(@simple_file, :reuse => false)
+      it "should be false with same book names but different excel instances" do
+        @new_book = Book.new(@simple_file, :excel => :new)
         @new_book.should_not == @book
       end
 
@@ -800,11 +1544,41 @@ describe RobustExcelOle::Book do
       end
     end
 
+    context "with visible and displayalerts" do
+
+      before do
+        @book = Book.open(@simple_file)
+      end
+
+      after do
+        @book.close
+      end
+
+      it "should make Excel visible" do
+        @book.visible = false
+        @book.excel.visible.should be_false
+        @book.visible.should be_false
+        @book.visible = true
+        @book.excel.visible.should be_true
+        @book.visible.should be_true
+      end
+
+      it "should enable DisplayAlerts in Excel" do
+        @book.displayalerts = false
+        @book.excel.displayalerts.should be_false
+        @book.displayalerts.should be_false
+        @book.displayalerts = true
+        @book.excel.displayalerts.should be_true
+        @book.displayalerts.should be_true
+      end
+
+    end
+
   end
 
   describe "#add_sheet" do
     before do
-      @book = RobustExcelOle::Book.open(@simple_file)
+      @book = Book.open(@simple_file)
       @sheet = @book[0]
     end
 
@@ -869,7 +1643,6 @@ describe RobustExcelOle::Book do
           @book.add_sheet(:after => @sheet).name.should eq @book[1].name
         end
       end
-
     end
 
     context "without argument" do
@@ -883,11 +1656,22 @@ describe RobustExcelOle::Book do
         sheet.name.should eq copyed_sheet.name
       end
     end
+
+    context "should raise error if the sheet name already exists" do
+      it "should raise error with giving a name that already exists" do
+        @book.add_sheet(@sheet, :as => 'new_sheet')
+        expect{
+          @book.add_sheet(@sheet, :as => 'new_sheet')
+          }.to raise_error(ExcelErrorSheet, "sheet name already exists")
+      end
+    end
+
+
   end
 
   describe 'access sheet' do
     before do
-      @book = RobustExcelOle::Book.open(@simple_file)
+      @book = Book.open(@simple_file)
     end
 
     after do
@@ -895,23 +1679,23 @@ describe RobustExcelOle::Book do
     end
 
     it 'with sheet name' do
-      @book['Sheet1'].should be_kind_of RobustExcelOle::Sheet
+      @book['Sheet1'].should be_kind_of Sheet
     end
 
     it 'with integer' do
-      @book[0].should be_kind_of RobustExcelOle::Sheet
+      @book[0].should be_kind_of Sheet
     end
 
     it 'with block' do
       @book.each do |sheet|
-        sheet.should be_kind_of RobustExcelOle::Sheet
+        sheet.should be_kind_of Sheet
       end
     end
 
     context 'open with block' do
       it {
-        RobustExcelOle::Book.open(@simple_file) do |book|
-          book['Sheet1'].should be_a RobustExcelOle::Sheet
+        Book.open(@simple_file) do |book|
+          book['Sheet1'].should be_a Sheet
         end
       }
     end