robust_excel_ole 0.2.0

data/lib/robust_excel_ole/sheet.rb

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+module RobustExcelOle
+  class Sheet
+    attr_reader :sheet
+    include Enumerable
+
+    def initialize(win32_worksheet)
+      @sheet = win32_worksheet
+      if @sheet.ProtectContents
+        @sheet.Unprotect
+        @end_row = last_row
+        @end_column = last_column
+        @sheet.Protect
+      else
+        @end_row = last_row
+        @end_column = last_column
+      end
+    end
+
+    def name
+      @sheet.Name
+    end
+
+    def name= (new_name)
+      @sheet.Name = new_name
+    end
+
+    def [] y, x
+      yx = "#{y+1}_#{x+1}"
+      @cells ||= { }
+      @cells[yx] ||= RobustExcelOle::Cell.new(@sheet.Cells.Item(y+1, x+1))
+    end
+
+    def []= (y, x, value)
+      @sheet.Cells.Item(y+1, x+1).Value = value
+    end
+
+    def each
+      each_row do |row_range|
+        row_range.each do |cell|
+          yield cell
+        end
+      end
+    end
+
+    def each_row(offset = 0)
+      offset += 1
+      1.upto(@end_row) do |row|
+        next if row < offset
+        yield RobustExcelOle::Range.new(@sheet.Range(@sheet.Cells(row, 1), @sheet.Cells(row, @end_column)))
+      end
+    end
+
+    def each_row_with_index(offset = 0)
+      each_row(offset) do |row_range|
+        yield RobustExcelOle::Range.new(row_range), (row_range.row - 1 - offset)
+      end
+    end
+
+    def each_column(offset = 0)
+      offset += 1
+      1.upto(@end_column) do |column|
+        next if column < offset
+        yield RobustExcelOle::Range.new(@sheet.Range(@sheet.Cells(1, column), @sheet.Cells(@end_row, column)))
+      end
+    end
+
+    def each_column_with_index(offset = 0)
+      each_column(offset) do |column_range|
+        yield RobustExcelOle::Range.new(column_range), (column_range.column - 1 - offset)
+      end
+    end
+
+    def row_range(row, range = nil)
+      range ||= 0..@end_column - 1
+      RobustExcelOle::Range.new(@sheet.Range(@sheet.Cells(row + 1, range.min + 1), @sheet.Cells(row + 1, range.max + 1)))
+    end
+
+    def col_range(col, range = nil)
+      range ||= 0..@end_row - 1
+      RobustExcelOle::Range.new(@sheet.Range(@sheet.Cells(range.min + 1, col + 1), @sheet.Cells(range.max + 1, col + 1)))
+    end
+
+    def method_missing(id, *args)
+      @sheet.send(id, *args)
+    end
+
+    private
+    def last_row
+      special_last_row = @sheet.UsedRange.SpecialCells(RobustExcelOle::XlLastCell).Row
+      used_last_row = @sheet.UsedRange.Rows.Count
+
+      special_last_row >= used_last_row ? special_last_row : used_last_row
+    end
+
+    def last_column
+      special_last_column = @sheet.UsedRange.SpecialCells(RobustExcelOle::XlLastCell).Column
+      used_last_column = @sheet.UsedRange.Columns.Count
+
+      special_last_column >= used_last_column ? special_last_column : used_last_column
+    end
+  end
+end

data/lib/robust_excel_ole/sp

@@ -0,0 +1,3 @@
+module RobustExcelOle
+  VERSION = "0.1.0"
+end

data/lib/robust_excel_ole/version.rb

@@ -0,0 +1,3 @@
+module RobustExcelOle
+  VERSION = "0.2.0"
+end

data/lib/spec_helper.rb

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+require "rspec"
+require 'tmpdir'
+require "fileutils"
+require File.join(File.dirname(__FILE__), '../lib/robust_excel_ole')
+
+module RobustExcelOle::SpecHelpers
+  def create_tmpdir
+    tmpdir = Dir.mktmpdir
+    FileUtils.cp_r(File.join(File.dirname(__FILE__), 'data'), tmpdir)
+    tmpdir + '/data'
+  end
+
+  def rm_tmp(tmpdir)
+    FileUtils.remove_entry_secure(File.dirname(tmpdir))
+  end
+
+  # This method is almost copy of wycats's implementation.
+  # http://pochi.hatenablog.jp/entries/2010/03/24
+  def capture(stream)
+    begin
+      stream = stream.to_s
+      eval "$#{stream} = StringIO.new"
+      yield
+      result = eval("$#{stream}").string
+    ensure
+      eval("$#{stream} = #{stream.upcase}")
+    end
+    result
+  end
+end
+
+RSpec.configure do |config|
+  config.include RobustExcelOle::SpecHelpers
+end

data/robust_excel_ole.gemspec

@@ -0,0 +1,32 @@
+# -*- coding: utf-8; mode: ruby -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "robust_excel_ole/version"
+
+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.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.rubyforge_project = "robust_excel_ole"
+
+  s.files         = `git ls-files`.split("\n")
+  s.rdoc_options += [
+                     '--main', 'README.rdoc',
+                     '--charset', 'utf-8'
+                    ]
+  s.extra_rdoc_files = ['README.rdoc', 'LICENSE']
+
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.add_development_dependency "rake", '>= 0.9.2'
+  s.add_development_dependency "rspec", '>= 2.6.0'
+  s.add_development_dependency "rb-fchange", '>= 0.0.5'
+  s.add_development_dependency "wdm", '>= 0.0.3'
+  s.add_development_dependency "win32console", '>= 1.3.2'
+  s.add_development_dependency "guard-rspec", '>= 2.1.1'
+end

data/robust_excel_ole_example.rb

@@ -0,0 +1,29 @@
+#'require 'lib/robust_excel_ole'
+require File.join(File.dirname(__FILE__), './lib/robust_excel_ole')
+book = RobustExcelOle::Book.open('./map1.xls', :read_only => false)
+sheet = book[0]
+cell = sheet[0,0]
+puts "cell: #{cell}"
+i = 0
+sheet.each do |cell|
+  i = i + 1
+  puts "#{i}. Zelle: #{cell} Wert: #{cell.value}"
+end
+i = 0
+sheet.each_row do |row|
+  i = i + 1
+  puts "#{i}. Reihe: #{row}"
+end
+i = 0
+sheet.each_column do |column|
+  i = i + 1
+  puts "#{i}. Spalte: #{column}"
+end
+a = column_range[1]
+#row = row_range[0]
+#puts "row: #{r}"
+book.save('./map2.xls', :if_exists => :overwrite)
+book.save('./map2.xls', :if_exists => :excel)
+book.save './map2.xls'
+book.save
+book.close

data/spec/book_spec.rb

@@ -0,0 +1,867 @@
+
+# -*- coding: utf-8 -*-
+
+require File.join(File.dirname(__FILE__), './spec_helper')
+
+
+$VERBOSE = nil
+
+describe RobustExcelOle::Book do
+
+  before(:all) do
+    excel_app = RobustExcelOle::ExcelApp.new(:reuse => true)
+    open_books = excel_app == nil ? 0 : excel_app.Workbooks.Count 
+    puts "*** open books *** : #{open_books}" if open_books > 0
+    RobustExcelOle::ExcelApp.close_all
+  end
+
+
+  before do
+    @dir = create_tmpdir
+    @simple_file = @dir + '/simple.xls'
+    @simple_save_file = @dir + '/simple_save_file.xls'
+  end
+
+  after do
+    #RobustExcelOle::ExcelApp.close_all
+    rm_tmp(@dir)
+  end
+
+
+  context "class methods" do
+    context "create file" 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.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")
+      end
+    end
+
+    context "with standard options" do
+      before do
+        @book = RobustExcelOle::Book.open(@simple_file)
+      end
+
+      after do
+        @book.close
+      end
+
+      it "should say that it lives" do
+        @book.should be_alive
+      end
+    end
+
+    context "with excel_app" do
+      before do
+        @new_book = RobustExcelOle::Book.open(@simple_file)
+      end
+      after do
+        @new_book.close
+      end
+      it "should provide the excel application of the book" do
+        excel_app = @new_book.excel_app
+        excel_app.class.should == RobustExcelOle::ExcelApp
+        excel_app.should be_a RobustExcelOle::ExcelApp
+      end
+    end
+
+    context "with :read_only" do
+      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
+        expect {
+          book.save_as(@simple_save_file, :if_exists => :overwrite)
+        }.to_not raise_error
+        book.close
+      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
+        expect {
+          book.save_as(@simple_save_file, :if_exists => :overwrite)
+        }.to_not raise_error
+        book.close
+      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
+        expect {
+          book.save_as(@simple_save_file, :if_exists => :overwrite)
+        }.to raise_error
+        book.close
+      end
+    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
+        end
+      end
+    end
+
+    context "with WIN32OLE#GetAbsolutePathName" do
+      it "'~' should be HOME directory" do
+        path = '~/Abrakadabra.xlsx'
+        expected_path = Regexp.new(File.expand_path(path).gsub(/\//, "."))
+        expect {
+          RobustExcelOle::Book.open(path)
+        }.to raise_error(ExcelErrorOpen, "file #{path} not found")
+      end
+    end
+
+    context "with an already opened book" do
+
+      before do
+        @book = RobustExcelOle::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_app.should == @book.excel_app
+              @different_book.excel_app.should == @book.excel_app
+            end     
+          end
+        end
+      end
+
+      context "with an unsaved book" do
+
+        before do
+          @book = RobustExcelOle::Book.open(@simple_file)
+          @sheet = @book[0]
+          @book.add_sheet(@sheet, :as => 'copyed_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 = RobustExcelOle::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 = RobustExcelOle::Book.open(@simple_file, :if_unsaved => :accept)
+            }.to_not raise_error
+          @book.should be_alive
+          @new_book.should be_alive
+          @new_book.filename.should == @book.filename
+        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
+
+        context "with :if_unsaved => :excel" 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 = RobustExcelOle::Book.open(@simple_file, :if_unsaved => :excel)
+            @book.should_not be_alive
+            @new_book.should be_alive
+            @new_book.filename.downcase.should == @simple_file.downcase
+          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_app.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 => :excel)
+              }.to raise_error(ExcelUserCanceled, "open: canceled by user")
+            @book.should be_alive
+          end
+        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_app.should_not == @book.excel_app
+          @new_book.close
+        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
+
+        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")
+        end
+
+      end
+    end
+
+    context "with an unsaved book in a different path" do
+
+      before do
+        simple_file_other_path = @dir + '/more_data/simple.xls'
+        @book = RobustExcelOle::Book.open(simple_file_other_path)
+        @sheet = @book[0]
+        @book.add_sheet(@sheet, :as => 'copyed_name')
+      end
+
+      after do
+        @book.close(:if_unsaved => :forget)
+        @new_book.close rescue nil
+      end
+
+      it "should raise an error, if :if_unsaved_other_book is :raise" do
+        expect {
+          @new_book = RobustExcelOle::Book.open(@simple_file, :if_unsaved_other_book => :raise)
+        }.to raise_error(ExcelErrorOpen, "blocked by an unsaved book with the same name in a different path")
+      end
+
+      it "should let the book open, if :if_unsaved_other_book is :save" do
+        expect {
+          @new_book = RobustExcelOle::Book.open(@simple_file, :if_unsaved_other_book => :save)
+          }.to_not raise_error
+        @book.should be_alive
+        @new_book.should be_alive
+        @new_book.filename.should == @book.filename
+      end
+
+      it "should close the other book and open the new book, if :if_unsaved_other_book is :forget" do
+        @new_book = RobustExcelOle::Book.open(@simple_file, :if_unsaved_other_book => :forget)
+        @book.should_not be_alive
+        @new_book.should be_alive
+        @new_book.filename.downcase.should == @simple_file.downcase
+      end
+
+      it "should open the book in a new excel application, if :if_unsaved_other_book is :new_app" do
+        @new_book = RobustExcelOle::Book.open(@simple_file, :if_unsaved_other_book => :new_app)
+        @book.should be_alive
+        @new_book.should be_alive
+        @new_book.filename.should_not == @book.filename
+        @new_book.excel_app.should_not == @book.excel_app
+        @new_book.close
+      end
+
+      it "should raise an error, if :if_unsaved_other_book is default" do
+        expect {
+          @new_book = RobustExcelOle::Book.open(@simple_file)
+        }.to raise_error(ExcelErrorOpen, "blocked by an unsaved book with the same name in a different path")
+      end
+
+      it "should raise an error, if :if_unsaved_other_book is invalid option" do
+        expect {
+          @new_book = RobustExcelOle::Book.open(@simple_file, :if_unsaved_other_book => :invalid_option)
+        }.to raise_error(ExcelErrorOpen, ":if_unsaved_other_book: invalid option")
+      end
+
+    end
+  end
+
+  describe "close" do
+
+    context "with saved book" do
+      before do
+        @book = RobustExcelOle::Book.open(@simple_file)
+      end
+
+      it "should close book" do
+        expect{
+          @book.close  
+        }.to_not raise_error   
+        @book.should_not be_alive    
+      end
+    end
+
+    context "with unsaved book" do
+      before do
+        @book = RobustExcelOle::Book.open(@simple_file)
+        @sheet_count = @book.workbook.Worksheets.Count
+        @book.add_sheet(@sheet, :as => 'copyed_name')
+        @sheet = @book[0]
+      end
+
+      after do
+        @book.close(:if_unsaved => :forget) rescue nil
+      end
+
+      it "should raise error with option :raise" do
+        expect{
+          @book.close(:if_unsaved => :raise)
+        }.to raise_error(ExcelErrorClose, "book is unsaved (#{File.basename(@simple_file)})")
+      end
+
+      it "should close the book and leave its file untouched with option :forget" do
+        ole_workbook = @book.workbook
+        excel_app = @book.excel_app
+        expect {
+          @book.close(:if_unsaved => :forget)
+        }.to change {excel_app.Workbooks.Count }.by(-1)
+        @book.workbook.should == nil
+        @book.should_not be_alive
+        expect{
+          ole_workbook.Name}.to raise_error(WIN32OLERuntimeError)
+        new_book = RobustExcelOle::Book.open(@simple_file)
+        begin
+          new_book.workbook.Worksheets.Count.should ==  @sheet_count
+        ensure
+          new_book.close
+        end
+      end
+
+      it "should save the book before close with option :save" do
+        ole_workbook = @book.workbook
+        excel_app = @book.excel_app
+        expect {
+          @book.close(:if_unsaved => :save)
+        }.to change {excel_app.Workbooks.Count }.by(-1)
+        @book.workbook.should == nil
+        @book.should_not be_alive
+        expect{
+          ole_workbook.Name}.to raise_error(WIN32OLERuntimeError)
+        new_book = RobustExcelOle::Book.open(@simple_file)
+        begin
+          new_book.workbook.Worksheets.Count.should == @sheet_count + 1
+        ensure
+          new_book.close
+        end
+      end
+
+      context "with :if_unsaved => :excel" do
+        before do
+          @key_sender = IO.popen  'ruby "' + File.join(File.dirname(__FILE__), '/helpers/key_sender.rb') + '" "Microsoft Excel" '  , "w"
+        end
+
+        after do
+          @key_sender.close
+        end
+
+        possible_answers = [:yes, :no, :cancel]
+        possible_answers.each_with_index do |answer, position|
+          it "should" + (answer == :yes ? "" : " not") + " the unsaved book and" + (answer == :cancel ? " not" : "") + " close it" + "if user answers '#{answer}'" do
+            # "Yes" is the  default. "No" is right of "Yes", "Cancel" is right of "No" --> language independent
+            @key_sender.puts  "{right}" * position + "{enter}"
+            ole_workbook = @book.workbook
+            excel_app = @book.excel_app 
+            displayalert_value = @book.excel_app.DisplayAlerts
+            if answer == :cancel then
+              expect {
+              @book.close(:if_unsaved => :excel)
+              }.to raise_error(ExcelUserCanceled, "close: canceled by user")
+              @book.workbook.Saved.should be_false
+              @book.workbook.should_not == nil
+              @book.should be_alive
+            else
+              expect {
+                @book.close(:if_unsaved => :excel)
+              }.to change {@book.excel_app.Workbooks.Count }.by(-1)
+              @book.workbook.should == nil
+              @book.should_not be_alive
+              expect{ole_workbook.Name}.to raise_error(WIN32OLERuntimeError)
+            end
+            new_book = RobustExcelOle::Book.open(@simple_file, :if_unsaved => :forget)
+            begin
+              new_book.workbook.Worksheets.Count.should == @sheet_count + (answer==:yes ? 1 : 0)
+              new_book.excel_app.DisplayAlerts.should == displayalert_value
+            ensure
+              new_book.close
+            end
+          end
+        end
+      end
+
+      it "should raise error for default" do
+        expect{
+          @book.close
+        }.to raise_error(ExcelErrorClose, "book is unsaved (#{File.basename(@simple_file)})")
+      end
+
+      it "should raise error for invalid option" do
+        expect{
+          @book.close(:if_unsaved => :invalid)
+        }.to raise_error(ExcelErrorClose, ":if_unsaved: invalid option")
+      end
+    end
+  end
+
+  describe "save" do
+    
+    context "with simple save" do
+      it "should save for a file opened without :read_only" do
+        @book = RobustExcelOle::Book.open(@simple_file)
+        @book.add_sheet(@sheet, :as => 'copyed_name')
+        @new_sheet_count = @book.workbook.Worksheets.Count
+        expect {
+          @book.save
+        }.to_not raise_error
+        @book.workbook.Worksheets.Count.should ==  @new_sheet_count
+        @book.close
+      end
+
+      it "should raise error with read_only" do
+        @book = RobustExcelOle::Book.open(@simple_file, :read_only => true)
+        expect {
+          @book.save
+        }.to raise_error(IOError,
+                     "Not opened for writing(open with :read_only option)")
+        @book.close
+      end
+    end
+
+    context "with open with read only" do
+      before do
+        @book = RobustExcelOle::Book.open(@simple_file, :read_only => true)
+      end
+
+      after do
+        @book.close
+      end
+
+      it {
+        expect {
+          @book.save_as(@simple_file)
+        }.to raise_error(IOError,
+                     "Not opened for writing(open with :read_only option)")
+      }
+    end
+
+    context "with argument" do
+      before do
+        RobustExcelOle::Book.open(@simple_file) do |book|
+          book.save_as(@simple_save_file, :if_exists => :overwrite)
+        end
+      end
+
+      it "should save to 'simple_save_file.xlsx'" do
+        File.exist?(@simple_save_file).should be_true
+      end
+    end
+
+    context "with different extensions" do
+      before do
+        @book = RobustExcelOle::Book.open(@simple_file)
+      end
+
+      after do
+        @book.close
+      end
+
+      possible_extensions = ['xls', 'xlsm', 'xlsx']
+      possible_extensions.each do |extensions_value|
+        it "should save to 'simple_save_file.#{extensions_value}'" do
+          simple_save_file = @dir + '/simple_save_file.' + extensions_value
+          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.close
+        end
+      end
+    end
+
+    # options :overwrite, :raise, :excel, no option, invalid option
+    possible_displayalerts = [true, false]
+    possible_displayalerts.each do |displayalert_value|
+      context "with displayalerts=#{displayalert_value}" do
+        before do
+          @book = RobustExcelOle::Book.open(@simple_file, :displayalerts => displayalert_value)
+        end
+
+        after do
+          @book.close
+        end
+
+        it "should save to simple_save_file.xls with :if_exists => :overwrite" do
+          File.delete @simple_save_file rescue nil
+          File.open(@simple_save_file,"w") do | file |
+            file.puts "garbage"
+          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.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
+          File.open(@simple_save_file,"w") do | file |
+            file.puts "garbage"
+          end
+          File.exist?(@simple_save_file).should be_true
+          booklength = File.size?(@simple_save_file)
+          expect {
+            @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
+        end
+
+        context "with :if_exists => :excel" do
+          before do
+            File.delete @simple_save_file rescue nil
+            File.open(@simple_save_file,"w") do | file |
+              file.puts "garbage"
+            end
+            @garbage_length = File.size?(@simple_save_file)
+            @key_sender = IO.popen  'ruby "' + File.join(File.dirname(__FILE__), '/helpers/key_sender.rb') + '" "Microsoft Excel" '  , "w"
+          end
+
+          after do
+            @key_sender.close
+          end
+
+          it "should save if user answers 'yes'" do
+            # "Yes" is to the left of "No", which is the  default. --> language independent
+            @key_sender.puts "{left}{enter}" #, :initial_wait => 0.2, :if_target_missing=>"Excel window not found")
+            @book.save_as(@simple_save_file, :if_exists => :excel)
+            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_app.DisplayAlerts.should == displayalert_value
+            new_book.close
+          end
+
+          it "should not save if user answers 'no'" do
+            # Just give the "Enter" key, because "No" is the default. --> language independent
+            # strangely, in the "no" case, the question will sometimes be repeated three times
+            @key_sender.puts "{enter}"
+            @key_sender.puts "{enter}"
+            @key_sender.puts "{enter}"
+            #@key_sender.puts "%{n}" #, :initial_wait => 0.2, :if_target_missing=>"Excel window not found")
+            @book.save_as(@simple_save_file, :if_exists => :excel)
+            File.exist?(@simple_save_file).should be_true
+            File.size?(@simple_save_file).should == @garbage_length
+          end
+
+          it "should not save and raise an exception if user answers 'cancel'" do
+            # Just give the "Enter" key, because "No" is the default. --> language independent
+            # strangely, in the "no" case, the question will sometimes be repeated three times
+            @key_sender.puts "{right}{enter}"
+            @key_sender.puts "{right}{enter}"
+            @key_sender.puts "{right}{enter}"
+            expect{
+              @book.save_as(@simple_save_file, :if_exists => :excel)
+              }.to raise_error(ExcelUserCanceled, "save: canceled by user")
+            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_app.DisplayAlerts.should == displayalert_value
+            new_book.close
+          end
+
+
+          it "should report save errors and leave DisplayAlerts unchanged" do
+            #@key_sender.puts "{left}{enter}" #, :initial_wait => 0.2, :if_target_missing=>"Excel window not found")
+            @book.workbook.Close
+            expect{
+              @book.save_as(@simple_save_file, :if_exists => :excel)
+              }.to raise_error(ExcelErrorSaveUnknown)
+            File.exist?(@simple_save_file).should be_true
+            File.size?(@simple_save_file).should == @garbage_length
+            @book.excel_app.DisplayAlerts.should == displayalert_value
+          end
+
+
+        end
+
+        it "should save to 'simple_save_file.xls' with :if_exists => nil" do
+          dirname, basename = File.split(@simple_save_file)
+          File.delete @simple_save_file rescue nil
+          File.open(@simple_save_file,"w") do | file |
+            file.puts "garbage"
+          end
+          File.exist?(@simple_save_file).should be_true
+          booklength = File.size?(@simple_save_file)
+          expect {
+            @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
+        end
+
+        it "should save to 'simple_save_file.xls' with :if_exists => :invalid_option" do
+          File.delete @simple_save_file rescue nil
+          @book.save_as(@simple_save_file)
+          expect {
+            @book.save_as(@simple_save_file, :if_exists => :invalid_option)
+            }.to raise_error(ExcelErrorSave, ':if_exists: invalid option')
+        end
+      end
+    end
+  end
+
+  describe "== , alive?, filename, absolute_path" do
+
+    context "with absolute_path" do
+      before do
+        @book = RobustExcelOle::Book.open(@simple_file)
+      end
+
+      after do
+        @book.close 
+      end
+
+      it "should return right absoute path name" do
+        @book.absolute_path(@simple_file).gsub("\\","/").should == @book.filename
+      end 
+    end
+
+    context "with alive?" do
+
+      before do
+        @book = RobustExcelOle::Book.open(@simple_file)
+      end
+
+      after do
+        @book.close 
+      end
+
+      it "should return true, if book is alive" do
+        @book.should be_alive
+      end
+
+      it "should return false, if book is dead" do
+        @book.close
+        @book.should_not be_alive
+      end
+
+    end
+
+    context "with filename" do
+
+      before do
+        @book = RobustExcelOle::Book.open(@simple_file)
+      end
+
+      after do
+        @book.close
+      end
+
+      it "should return full file name" do
+        @book.filename.should == @simple_file
+      end
+
+      it "should return nil for dead book" do
+        @book.close
+        @book.filename.should == nil
+      end
+
+    end
+
+    context "with ==" do
+
+      before do
+        @book = RobustExcelOle::Book.open(@simple_file)
+      end
+
+      after do
+        @book.close
+        @new_book.close rescue nil
+      end
+
+      it "should be true with two identical books" do
+        @new_book = RobustExcelOle::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.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)
+        @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)
+        @new_book.should_not == @book
+      end
+
+      it "should be false with non-Books" do
+        @book.should_not == "hallo"
+        @book.should_not == 7
+        @book.should_not == nil
+      end
+    end
+
+  end
+
+  describe "#add_sheet" do
+    before do
+      @book = RobustExcelOle::Book.open(@simple_file)
+      @sheet = @book[0]
+    end
+
+    after do
+      @book.close(:if_unsaved => :forget)
+    end
+
+    context "only first argument" do
+      it "should add worksheet" do
+        expect { @book.add_sheet @sheet }.to change{ @book.workbook.Worksheets.Count }.from(3).to(4)
+      end
+
+      it "should return copyed sheet" do
+        sheet = @book.add_sheet @sheet
+        copyed_sheet = @book.workbook.Worksheets.Item(@book.workbook.Worksheets.Count)
+        sheet.name.should eq copyed_sheet.name
+      end
+    end
+
+    context "with first argument" do
+      context "with second argument is {:as => 'copyed_name'}" do
+        it "copyed sheet name should be 'copyed_name'" do
+          @book.add_sheet(@sheet, :as => 'copyed_name').name.should eq 'copyed_name'
+        end
+      end
+
+      context "with second argument is {:before => @sheet}" do
+        it "should add the first sheet" do
+          @book.add_sheet(@sheet, :before => @sheet).name.should eq @book[0].name
+        end
+      end
+
+      context "with second argument is {:after => @sheet}" do
+        it "should add the first sheet" do
+          @book.add_sheet(@sheet, :after => @sheet).name.should eq @book[1].name
+        end
+      end
+
+      context "with second argument is {:before => @book[2], :after => @sheet}" do
+        it "should arguments in the first is given priority" do
+          @book.add_sheet(@sheet, :before => @book[2], :after => @sheet).name.should eq @book[2].name
+        end
+      end
+
+    end
+
+    context "without first argument" do
+      context "second argument is {:as => 'new sheet'}" do
+        it "should return new sheet" do
+          @book.add_sheet(:as => 'new sheet').name.should eq 'new sheet'
+        end
+      end
+
+      context "second argument is {:before => @sheet}" do
+        it "should add the first sheet" do
+          @book.add_sheet(:before => @sheet).name.should eq @book[0].name
+        end
+      end
+
+      context "second argument is {:after => @sheet}" do
+        it "should add the second sheet" do
+          @book.add_sheet(:after => @sheet).name.should eq @book[1].name
+        end
+      end
+
+    end
+
+    context "without argument" do
+      it "should add empty sheet" do
+        expect { @book.add_sheet }.to change{ @book.workbook.Worksheets.Count }.from(3).to(4)
+      end
+
+      it "should return copyed sheet" do
+        sheet = @book.add_sheet
+        copyed_sheet = @book.workbook.Worksheets.Item(@book.workbook.Worksheets.Count)
+        sheet.name.should eq copyed_sheet.name
+      end
+    end
+  end
+
+  describe 'access sheet' do
+    before do
+      @book = RobustExcelOle::Book.open(@simple_file)
+    end
+
+    after do
+      @book.close
+    end
+
+    it 'with sheet name' do
+      @book['Sheet1'].should be_kind_of RobustExcelOle::Sheet
+    end
+
+    it 'with integer' do
+      @book[0].should be_kind_of RobustExcelOle::Sheet
+    end
+
+    it 'with block' do
+      @book.each do |sheet|
+        sheet.should be_kind_of RobustExcelOle::Sheet
+      end
+    end
+
+    context 'open with block' do
+      it {
+        RobustExcelOle::Book.open(@simple_file) do |book|
+          book['Sheet1'].should be_a RobustExcelOle::Sheet
+        end
+      }
+    end
+  end
+
+end