robust_excel_ole 1.14 → 1.18.1

data/spec/bookstore_spec.rb

@@ -159,7 +159,7 @@ describe Bookstore do
       it "should not fetch anything to a not existing network path file" do
         @book1 = Workbook.open(@hostname_share_path)
         @bookstore.store(@book1)
-        @bookstore.fetch(@network_path_not_existing).should == nil
+        #@bookstore.fetch(@network_path_not_existing).should == nil
       end
 
       # nice to have
@@ -175,7 +175,7 @@ describe Bookstore do
       it "should not fetch anything to a not existing network path file the stored absolute path file" do
         @book1 = Workbook.open(@absolute_file_path)
         @bookstore.store(@book1)
-        @bookstore.fetch(@network_path_not_existing).should == nil
+        #@bookstore.fetch(@network_path_not_existing).should == nil
       end
 
       it "should fetch to a given hostname share path file the stored network path file" do
@@ -581,7 +581,7 @@ describe Bookstore do
     end
 
     it "should print books" do
-      @bookstore.print
+      @bookstore.print_filename2books
     end
 
   end

data/spec/cell_spec.rb

@@ -15,54 +15,66 @@ describe Cell do
 
   before do
     @dir = create_tmpdir
+    @simple_file = @dir + '/workbook.xls'
+    @merge_cells_file = @dir + '/merge_cells.xls'
+    @book = Workbook.open(@simple_file)
+    @sheet = @book.sheet(1)
+    @cell = @sheet[1, 1]
   end
 
   after do
+    Excel.kill_all
     rm_tmp(@dir)
   end
 
-  context "open simple.xls" do
-    before do
-      @book = Workbook.open(@dir + '/workbook.xls', :read_only => true)
-      @sheet = @book.sheet(2)
-      @cell = @sheet[1, 1]
+
+  describe "values" do
+
+    it "should yield one element values" do
+      @cell.values.should == ["foo"]
     end
 
-    after do
-      @book.close
+  end
+
+  describe "#[]" do
+
+    it "should access to the cell itself" do
+      @cell[0].should be_kind_of RobustExcelOle::Cell
+      @cell[0].v.should == "foo"
     end
 
-    describe "#value" do
-      it "get cell's value" do
-        @cell.Value.should eq 'simple'
-      end
+    it "should access to the cell itself" do
+      @cell[1].should be_kind_of RobustExcelOle::Cell
+      @cell[1].v.should == 'foo'
     end
+    
+  end
 
-    describe "#value=" do
-      it "change cell data to 'fooooo'" do
-        @cell.Value = 'fooooo'
-        @cell.Value.should eq 'fooooo'
-      end
+  describe "#copy" do
+  
+    before do
+      @book1 = Workbook.open(@dir + '/workbook.xls')
+      @sheet1 = @book1.sheet(1)
+      @cell1 = @sheet1[1,1]
     end
 
-    describe "#method_missing" do
-      context "unknown method" do
-        it { expect { @cell.hogehogefoo }.to raise_error }
-      end
+    after do
+      @book1.close(:if_unsaved => :forget)
     end
 
+    it "should copy range" do
+      @cell1.copy([2,3])
+      @sheet1.range([1..2,1..3]).v.should == [["foo", "workbook", "sheet1"],["foo", nil, "foo"]]
+    end
   end
 
   context "open merge_cells.xls" do
+ 
     before do
-      @book = Workbook.open(@dir + '/merge_cells.xls', :read_only => true)
+      @book = Workbook.open(@merge_cells_file, :read_only => true)
       @sheet = @book.sheet(1)
     end
 
-    after do
-      @book.close
-    end
-
     it "merged cell get same value" do
       @sheet[1, 1].Value.should be_nil
       @sheet[2, 1].Value.should eq 'first merged'
@@ -74,4 +86,34 @@ describe Cell do
       @sheet[2, 2].Value.should eq "set merge cell"
     end
   end
+
+  describe "==" do
+
+    it "should check equality of cells" do
+      @cell.should == @sheet[1,1]
+      @cell.should_not == @sheet[1,2]
+    end
+
+  end
+
+  describe "#Value" do
+    it "get cell's value" do
+      @cell.Value.should eq 'foo'
+    end
+  end
+
+  describe "#Value=" do
+    it "change cell data to 'fooooo'" do
+      @cell.Value = 'fooooo'
+      @cell.Value.should eq 'fooooo'
+    end
+  end
+
+  describe "#method_missing" do
+    context "unknown method" do
+      it { expect { @cell.hogehogefoo }.to raise_error(NoMethodError) }
+    end
+  end
+
 end
+

data/spec/excel_spec.rb

@@ -23,6 +23,11 @@ module RobustExcelOle
       @invalid_name_file = 'b/workbook.xls'
       @simple_file1 = @simple_file
       @different_file1 = @different_file
+      @error_unsaved_workbooks = "Excel contains unsaved workbooks" +
+              "\nHint: Use option :if_unsaved with values :forget and :save to close the 
+           Excel instance without or with saving the unsaved workbooks before, respectively"
+      @error_invalid_option = ":if_unsaved: invalid option: :invalid_option" +
+              "\nHint: Valid values are :raise, :forget, :save and :alert"
     end
 
     after do
@@ -30,6 +35,22 @@ module RobustExcelOle
       rm_tmp(@dir)
     end
 
+    context "active_workbook" do
+
+      before do
+        @excel = Excel.create
+      end
+
+      it "should access the active workbook" do
+        @excel.active_workbook.should be nil
+        workbook = Workbook.open(@simple_file1)
+        active_workbook = @excel.active_workbook
+        active_workbook.Fullname.should == workbook.Fullname
+        active_workbook.should == workbook
+      end
+
+    end
+
     context "with connect and preserving options" do
 
       before do
@@ -271,16 +292,16 @@ module RobustExcelOle
           ole_excel = WIN32OLE.new("Excel.Application")  
           reo_excel = Excel.new(ole_excel)
           reo_excel.ole_excel.Hwnd.should == ole_excel.Hwnd  
-          reo_excel.visible.should == false
-          reo_excel.displayalerts.should == :if_visible
+          reo_excel.Visible.should == false
+          reo_excel.properties[:displayalerts].should == :if_visible
         end
 
         it "lifts an Excel instance given as WIN32OLE object and set options" do
           app = WIN32OLE.new('Excel.Application')
           ole_excel = WIN32OLE.connect("Excel.Application")  
           reo_excel = Excel.new(ole_excel, {:displayalerts => true, :visible => true})
-          ole_excel.visible.should == true
-          ole_excel.displayalerts.should == true
+          ole_excel.Visible.should == true
+          ole_excel.DisplayAlerts.should == true
         end
 
 
@@ -627,15 +648,13 @@ module RobustExcelOle
             @excel2 = book2.excel
             sheet2 = book2.sheet(1)
             @old_cell_value2 = sheet2[1,1].Value
-            sheet2[1,1] = sheet2[1,1].Value == "foo" ? "bar" : "foo"
+            sheet2[1,1] = sheet2[1,1].Value == "foo" ? "bar" : "foo"            
           end
 
           it "should close the first Excel without unsaved workbooks and then raise an error" do
             expect{
               Excel.close_all(:if_unsaved => :raise)
-            }.to raise_error(UnsavedWorkbooks, "Excel contains unsaved workbooks" +
-              "\nHint: Use option :if_unsaved with values :forget and :save to close the 
-           Excel instance without or with saving the unsaved workbooks before, respectively")
+            }.to raise_error(UnsavedWorkbooks, @error_unsaved_workbooks)
             sleep 0.2
             @excel1.should_not be_alive
             @excel2.should be_alive
@@ -648,9 +667,7 @@ module RobustExcelOle
           it "should close the first Excel without unsaved workbooks and then raise an error" do
             expect{
               Excel.close_all
-            }.to raise_error(UnsavedWorkbooks, "Excel contains unsaved workbooks" +
-              "\nHint: Use option :if_unsaved with values :forget and :save to close the 
-           Excel instance without or with saving the unsaved workbooks before, respectively")
+            }.to raise_error(UnsavedWorkbooks, @error_unsaved_workbooks)
             sleep 0.2
             @excel1.should_not be_alive
             @excel2.should be_alive
@@ -687,8 +704,7 @@ module RobustExcelOle
           it "should raise an error for invalid option" do
             expect {
               Excel.close_all(:if_unsaved => :invalid_option)
-            }.to raise_error(OptionInvalid, ":if_unsaved: invalid option: :invalid_option" +
-              "\nHint: Valid values are :raise, :forget, :save and :alert") 
+            }.to raise_error(OptionInvalid, @error_invalid_option) 
           end
         end
 
@@ -705,9 +721,7 @@ module RobustExcelOle
           it "should close the 1st and 3rd Excel instances that have saved workbooks" do  
             expect{
               Excel.close_all(:if_unsaved => :raise)
-            }.to raise_error(UnsavedWorkbooks, "Excel contains unsaved workbooks" +
-              "\nHint: Use option :if_unsaved with values :forget and :save to close the 
-           Excel instance without or with saving the unsaved workbooks before, respectively")
+            }.to raise_error(UnsavedWorkbooks, @error_unsaved_workbooks)
             sleep 0.2
             @book1.excel.should_not be_alive
             @book2.excel.should be_alive
@@ -732,9 +746,7 @@ module RobustExcelOle
           it "should close three Excel instances that have saved workbooks" do  
             expect{
               Excel.close_all(:if_unsaved => :raise)
-            }.to raise_error(UnsavedWorkbooks, "Excel contains unsaved workbooks" +
-              "\nHint: Use option :if_unsaved with values :forget and :save to close the 
-           Excel instance without or with saving the unsaved workbooks before, respectively")
+            }.to raise_error(UnsavedWorkbooks, @error_unsaved_workbooks)
             sleep 0.2
             expect{
               @ole_xl.Name
@@ -812,17 +824,13 @@ module RobustExcelOle
         it "should raise an error" do
           expect{
             @excel.close(:if_unsaved => :raise)
-          }.to raise_error(UnsavedWorkbooks, "Excel contains unsaved workbooks" +
-            "\nHint: Use option :if_unsaved with values :forget and :save to close the 
-           Excel instance without or with saving the unsaved workbooks before, respectively")
+          }.to raise_error(UnsavedWorkbooks, @error_unsaved_workbooks)
         end        
 
         it "should raise an error per default" do
           expect{
             @excel.close(:if_unsaved => :raise)
-          }.to raise_error(UnsavedWorkbooks, "Excel contains unsaved workbooks" +
-            "\nHint: Use option :if_unsaved with values :forget and :save to close the 
-           Excel instance without or with saving the unsaved workbooks before, respectively")
+          }.to raise_error(UnsavedWorkbooks, @error_unsaved_workbooks)
         end        
 
         it "should close the Excel without saving the workbook" do
@@ -865,8 +873,7 @@ module RobustExcelOle
         it "should raise an error for invalid option" do
           expect {
             @excel.close(:if_unsaved => :invalid_option)
-          }.to raise_error(OptionInvalid, ":if_unsaved: invalid option: :invalid_option" +
-            "\nHint: Valid values are :raise, :forget, :save and :alert") 
+          }.to raise_error(OptionInvalid, @error_invalid_option) 
         end
       end
 
@@ -889,6 +896,8 @@ module RobustExcelOle
           # "Yes" is to the left of "No", which is the  default. --> language independent
           @excel.should be_alive
           @key_sender.puts "{enter}" 
+          @key_sender.puts "{enter}" 
+          @key_sender.puts "{enter}" 
           result = @excel.close(:if_unsaved => :alert)
           @excel.should_not be_alive
           result.should == 1
@@ -920,6 +929,7 @@ module RobustExcelOle
           @book.saved.should be false
           @key_sender.puts "{left}{enter}"
           @key_sender.puts "{left}{enter}"
+          @key_sender.puts "{left}{enter}"
           expect{
             @excel.close(:if_unsaved => :alert)
             }.to raise_error(ExcelREOError, "user canceled or runtime error")
@@ -952,18 +962,13 @@ module RobustExcelOle
         it "should raise error" do
           expect{
             @excel.close_workbooks(:if_unsaved => :raise)
-          }.to raise_error(UnsavedWorkbooks, "Excel contains unsaved workbooks" +
-          "\nHint: Use option :if_unsaved with values :forget and :save to close the 
-           Excel instance without or with saving the unsaved workbooks before, respectively" )
-
+          }.to raise_error(UnsavedWorkbooks, @error_unsaved_workbooks)
         end
 
         it "should raise error per default" do
           expect{
             @excel.close_workbooks
-          }.to raise_error(UnsavedWorkbooks, "Excel contains unsaved workbooks" +
-            "\nHint: Use option :if_unsaved with values :forget and :save to close the 
-           Excel instance without or with saving the unsaved workbooks before, respectively")
+          }.to raise_error(UnsavedWorkbooks, @error_unsaved_workbooks)
         end
 
         it "should close the workbook with forgetting the workbook" do
@@ -991,8 +996,7 @@ module RobustExcelOle
         it "should raise an error for invalid option" do
           expect {
             @excel.close_workbooks(:if_unsaved => :invalid_option)
-          }.to raise_error(OptionInvalid, ":if_unsaved: invalid option: :invalid_option" +
-            "\nHint: Valid values are :raise, :forget, :save and :alert") 
+          }.to raise_error(OptionInvalid, @error_invalid_option) 
         end
       end
     end
@@ -1254,55 +1258,55 @@ module RobustExcelOle
         excel2 = Excel.create
         excel1.focus
         excel1.Visible.should be true
-        excel1.visible.should be true
+        excel1.properties[:visible].should be true
       end
 
       it "should set default values" do
         excel1 = Excel.new
         excel1.Visible.should be false
         excel1.DisplayAlerts.should be false
-        excel1.visible.should be false
-        excel1.displayalerts.should == :if_visible
+        excel1.properties[:visible].should be false
+        excel1.properties[:displayalerts].should == :if_visible
       end
 
       it "should set visible true" do
         excel1 = Excel.new(:visible => true)
         excel1.Visible.should be true
         excel1.DisplayAlerts.should be true
-        excel1.visible.should be true
-        excel1.displayalerts.should == :if_visible
+        excel1.properties[:visible].should be true
+        excel1.properties[:displayalerts].should == :if_visible
       end
 
       it "should set visible false" do
         excel1 = Excel.new(:visible => false)
         excel1.Visible.should be false
         excel1.DisplayAlerts.should be false
-        excel1.visible.should be false
-        excel1.displayalerts.should == :if_visible
+        excel1.properties[:visible].should be false
+        excel1.properties[:displayalerts].should == :if_visible
       end
 
       it "should set displayalerts true" do
         excel1 = Excel.new(:displayalerts => true)
         excel1.Visible.should be false
         excel1.DisplayAlerts.should be true
-        excel1.visible.should be false
-        excel1.displayalerts.should be true
+        excel1.properties[:visible].should be false
+        excel1.properties[:displayalerts].should be true
       end
 
       it "should set displayalerts false" do
         excel1 = Excel.new(:displayalerts => false)
         excel1.Visible.should be false
         excel1.DisplayAlerts.should be false
-        excel1.visible.should be false
-        excel1.displayalerts.should be false
+        excel1.properties[:visible].should be false
+        excel1.properties[:displayalerts].should be false
       end
 
       it "should use values of the current Excel when reusing" do
         excel1 = Excel.create
         excel1.Visible.should be false
         excel1.DisplayAlerts.should be false
-        excel1.visible.should be false
-        excel1.displayalerts.should == :if_visible
+        excel1.properties[:visible].should be false
+        excel1.properties[:displayalerts].should == :if_visible
         excel1.Visible = true
         excel1.DisplayAlerts = true
         excel1.Visible.should be true
@@ -1316,49 +1320,49 @@ module RobustExcelOle
         excel1 = Excel.create
         excel2 = Excel.current
         excel2.Visible.should be false
-        excel2.visible.should be false
+        excel2.properties[:visible].should be false
         excel2.DisplayAlerts.should be false
-        excel2.displayalerts.should == :if_visible
+        excel2.properties[:displayalerts].should == :if_visible
       end
 
       it "should take Visible and DisplayAlerts from the connected Excel" do
         excel1 = Excel.create
         excel2 = Excel.current(:visible => true)
         excel2.Visible.should be true
-        excel2.visible.should be true
+        excel2.properties[:visible].should be true
         excel2.DisplayAlerts.should be true
-        excel2.displayalerts.should == :if_visible
+        excel2.properties[:displayalerts].should == :if_visible
       end
 
       it "should set Excel visible and invisible with current" do
         excel1 = Excel.new(:reuse => false, :visible => true)
         excel1.Visible.should be true
-        excel1.visible.should be true
+        excel1.properties[:visible].should be true
         excel1.DisplayAlerts.should be true
-        excel1.displayalerts.should == :if_visible
+        excel1.properties[:displayalerts].should == :if_visible
         excel1.visible = false
         excel1.Visible.should be false
-        excel1.visible.should be false
+        excel1.properties[:visible].should be false
         excel1.DisplayAlerts.should be false
-        excel1.displayalerts.should == :if_visible
+        excel1.properties[:displayalerts].should == :if_visible
         excel2 = Excel.current(:visible => true)
         excel2.Visible.should be true
-        excel2.visible.should be true
-        excel2.displayalerts.should == :if_visible
+        excel2.properties[:visible].should be true
+        excel2.properties[:displayalerts].should == :if_visible
         excel2.DisplayAlerts.should be true
       end
 
       it "should set Excel visible and invisible" do
         excel = Excel.new(:reuse => false, :visible => true)
         excel.Visible.should be true
-        excel.visible.should be true
+        excel.properties[:visible].should be true
         excel.DisplayAlerts.should be true
-        excel.displayalerts.should == :if_visible
+        excel.properties[:displayalerts].should == :if_visible
         excel.visible = false
         excel.Visible.should be false
-        excel.visible.should be false
+        excel.properties[:visible].should be false
         excel.DisplayAlerts.should be false
-        excel.displayalerts.should == :if_visible
+        excel.properties[:displayalerts].should == :if_visible
         excel7 = Excel.current
         excel7.should === excel
         excel7.Visible.should be false
@@ -1366,117 +1370,117 @@ module RobustExcelOle
         excel1 = Excel.create(:visible => true)
         excel1.should_not == excel
         excel1.Visible.should be true
-        excel1.visible.should be true
+        excel1.properties[:visible].should be true
         excel1.DisplayAlerts.should be true
-        excel1.displayalerts.should == :if_visible
+        excel1.properties[:displayalerts].should == :if_visible
         excel2 = Excel.create(:visible => false)
         excel2.Visible.should be false
-        excel2.visible.should be false
+        excel2.properties[:visible].should be false
         excel2.DisplayAlerts.should be false
-        excel2.displayalerts.should == :if_visible
+        excel2.properties[:displayalerts].should == :if_visible
         excel3 = Excel.current
         excel3.should === excel
         excel3.Visible.should be false
-        excel3.visible.should be false
+        excel3.properties[:visible].should be false
         excel3.DisplayAlerts.should be false
-        excel3.displayalerts.should == :if_visible
+        excel3.properties[:displayalerts].should == :if_visible
         excel4 = Excel.current(:visible => true)
         excel4.should === excel
         excel4.Visible.should be true
-        excel4.visible.should be true
+        excel4.properties[:visible].should be true
         excel4.DisplayAlerts.should be true
-        excel4.displayalerts.should == :if_visible
+        excel4.properties[:displayalerts].should == :if_visible
         excel5 = Excel.current(:visible => false)
         excel5.should === excel
         excel5.Visible.should be false
-        excel5.visible.should be false
+        excel5.properties[:visible].should be false
         excel5.DisplayAlerts.should be false
-        excel5.displayalerts.should == :if_visible
+        excel5.properties[:displayalerts].should == :if_visible
       end
 
       it "should enable or disable Excel DispayAlerts" do        
         excel = Excel.new(:reuse => false, :displayalerts => true)
         excel.DisplayAlerts.should be true
-        excel.displayalerts.should be true
+        excel.properties[:displayalerts].should be true
         excel.Visible.should be false
-        excel.visible.should be false
+        excel.properties[:visible].should be false
         excel6 = Excel.current
         excel6.should === excel
         excel6.DisplayAlerts.should be true
-        excel6.displayalerts.should be true
+        excel6.properties[:displayalerts].should be true
         excel6.Visible.should be false
-        excel6.visible.should be false
+        excel6.properties[:visible].should be false
         excel.displayalerts = false
         excel.DisplayAlerts.should be false
-        excel.displayalerts.should be false
+        excel.properties[:displayalerts].should be false
         excel.Visible.should be false
-        excel.visible.should be false
+        excel.properties[:visible].should be false
         excel7 = Excel.current
         excel7.should === excel
         excel7.DisplayAlerts.should be false
-        excel7.displayalerts.should be false
+        excel7.properties[:displayalerts].should be false
         excel7.Visible.should be false
-        excel7.visible.should be false
+        excel7.properties[:visible].should be false
         excel1 = Excel.create(:displayalerts => true)
         excel1.should_not == excel
         excel1.DisplayAlerts.should be true
-        excel1.displayalerts.should be true
+        excel1.properties[:displayalerts].should be true
         excel1.Visible.should be false
-        excel1.visible.should be false
+        excel1.properties[:visible].should be false
         excel2 = Excel.create(:displayalerts => false)
         excel2.DisplayAlerts.should be false
-        excel2.displayalerts.should be false
+        excel2.properties[:displayalerts].should be false
         excel2.Visible.should be false
-        excel2.visible.should be false
+        excel2.properties[:visible].should be false
         excel3 = Excel.current
         excel3.should === excel
         excel3.DisplayAlerts.should be false
-        excel3.displayalerts.should be false
+        excel3.properties[:displayalerts].should be false
         excel3.Visible.should be false
-        excel3.visible.should be false
+        excel3.properties[:visible].should be false
         excel4 = Excel.current(:displayalerts => true)
         excel4.should === excel
         excel4.DisplayAlerts.should be true
-        excel4.displayalerts.should be true
+        excel4.properties[:displayalerts].should be true
         excel4.Visible.should be false
-        excel4.visible.should be false
+        excel4.properties[:visible].should be false
         excel5 = Excel.current(:displayalerts => false)
         excel5.should === excel
         excel5.DisplayAlerts.should be false
-        excel5.displayalerts.should be false
+        excel5.properties[:displayalerts].should be false
         excel5.Visible.should be false
-        excel5.visible.should be false
+        excel5.properties[:visible].should be false
       end
 
       it "should set Excel visible and displayalerts" do        
         excel = Excel.new(:reuse => false, :visible => true, :displayalerts => true)
         excel.DisplayAlerts.should be true
-        excel.displayalerts.should be true
+        excel.properties[:displayalerts].should be true
         excel.Visible.should be true
-        excel.visible.should be true
+        excel.properties[:visible].should be true
         excel6 = Excel.current
         excel6.should === excel
         excel6.DisplayAlerts.should be true
-        excel6.displayalerts.should be true
+        excel6.properties[:displayalerts].should be true
         excel6.Visible.should be true
-        excel6.visible.should be true
+        excel6.properties[:visible].should be true
         excel.displayalerts = false
         excel.DisplayAlerts.should be false
-        excel.displayalerts.should be false
+        excel.properties[:displayalerts].should be false
         excel.Visible.should be true
-        excel.visible.should be true
+        excel.properties[:visible].should be true
         excel7 = Excel.current
         excel7.should === excel
         excel7.DisplayAlerts.should be false
-        excel7.displayalerts.should be false
+        excel7.properties[:displayalerts].should be false
         excel7.Visible.should be true
-        excel7.visible.should be true        
+        excel7.properties[:visible].should be true        
         excel2 = Excel.new(:reuse => false, :visible => true, :displayalerts => true)
         excel2.visible = false
         excel2.DisplayAlerts.should be true
-        excel2.displayalerts.should be true
+        excel2.properties[:displayalerts].should be true
         excel2.Visible.should be false
-        excel2.visible.should be false
+        excel2.properties[:visible].should be false
         excel3 = Excel.new(:reuse => false, :visible => true, :displayalerts => false)
         excel3.Visible.should be true
         excel3.DisplayAlerts.should be false
@@ -1488,21 +1492,21 @@ module RobustExcelOle
         excel3.DisplayAlerts.should be false
         excel4 = Excel.create(:visible => true, :displayalerts => true)
         excel4.DisplayAlerts.should be true
-        excel4.displayalerts.should be true
+        excel4.properties[:displayalerts].should be true
         excel4.Visible.should be true
-        excel4.visible.should be true
+        excel4.properties[:visible].should be true
         excel5 = Excel.current(:visible => true, :displayalerts => false)
         excel5.should === excel
         excel5.DisplayAlerts.should be false
-        excel5.displayalerts.should be false
+        excel5.properties[:displayalerts].should be false
         excel5.Visible.should be true
-        excel5.visible.should be true
+        excel5.properties[:visible].should be true
         excel6 = Excel.current(:visible => false, :displayalerts => true)
         excel6.should === excel
         excel6.DisplayAlerts.should be true
-        excel6.displayalerts.should be true
+        excel6.properties[:displayalerts].should be true
         excel6.Visible.should be false
-        excel6.visible.should be false
+        excel6.properties[:visible].should be false
       end
 
       it "should work with displayalerts == if_visible" do
@@ -1623,17 +1627,17 @@ module RobustExcelOle
 
       it "should create and reuse Excel with calculation mode" do
         excel1 = Excel.create(:calculation => :manual)
-        excel1.calculation.should == :manual
+        excel1.properties[:calculation].should == :manual
         excel2 = Excel.create(:calculation => :automatic)
-        excel2.calculation.should == :automatic
+        excel2.properties[:calculation].should == :automatic
         excel3 = Excel.current
-        excel3.calculation.should == :manual
+        excel3.properties[:calculation].should == :manual
         excel4 = Excel.current(:calculation => :automatic)
-        excel4.calculation.should == :automatic
+        excel4.properties[:calculation].should == :automatic
         excel5 = Excel.new(:reuse => false)
-        excel5.calculation.should == nil
+        excel5.properties[:calculation].should == nil
         excel6 = Excel.new(:reuse => false, :calculation => :manual)
-        excel6.calculation.should == :manual
+        excel6.properties[:calculation].should == :manual
       end
 
 =begin
@@ -1657,11 +1661,11 @@ module RobustExcelOle
         old_calculation_mode = @excel1.Calculation
         old_calculatebeforesave = @excel1.CalculateBeforeSave
         @excel1.calculation = :automatic
-        @excel1.calculation.should == :automatic
+        @excel1.properties[:calculation].should == :automatic
         @excel1.Calculation.should == old_calculation_mode 
         @excel1.CalculateBeforeSave.should == old_calculatebeforesave
         @excel1.calculation = :manual
-        @excel1.calculation.should == :manual
+        @excel1.properties[:calculation].should == :manual
         @excel1.Calculation.should == old_calculation_mode
         @excel1.CalculateBeforeSave.should == old_calculatebeforesave
       end
@@ -1673,7 +1677,7 @@ module RobustExcelOle
           book1 = Workbook.open(@simple_file1, :visible => false)
           expect( book1.Windows(1).Visible ).to be true # false
           expect {       excel1.calculation = :manual 
-            }.to change{ excel1.calculation 
+            }.to change{ excel1.properties[:calculation] 
           }.from(        :automatic
           ).to(          :manual )
         end
@@ -1683,7 +1687,7 @@ module RobustExcelOle
           book1 = Workbook.open(@simple_file1, :visible => false)
           expect( book1.Windows(1).Visible ).to be true # false
           expect {       excel1.calculation = :automatic 
-            }.to change{ excel1.calculation 
+            }.to change{ excel1.properties[:calculation] 
           }.from(        :manual
           ).to(          :automatic )
         end
@@ -1694,7 +1698,7 @@ module RobustExcelOle
         book = Workbook.open(@simple_file, :visible => true)
         old_calculation_mode = @excel1.Calculation
         @excel1.with_calculation(:manual) do
-          @excel1.calculation.should == :manual
+          @excel1.properties[:calculation].should == :manual
           @excel1.Calculation.should == XlCalculationManual
           @excel1.CalculateBeforeSave.should be false
           book.Saved.should be true
@@ -1702,7 +1706,7 @@ module RobustExcelOle
         @excel1.Calculation.should == old_calculation_mode
         @excel1.CalculateBeforeSave.should be false
         @excel1.with_calculation(:automatic) do
-          @excel1.calculation.should == :automatic
+          @excel1.properties[:calculation].should == :automatic
           @excel1.Calculation.should == XlCalculationAutomatic
           @excel1.CalculateBeforeSave.should be false
           book.Saved.should be false
@@ -1717,7 +1721,7 @@ module RobustExcelOle
         book.Saved.should be true
         book.Windows(book.Name).Visible = true
         @excel1.calculation = :manual
-        @excel1.calculation.should == :manual
+        @excel1.properties[:calculation].should == :manual
         @excel1.Calculation.should == XlCalculationManual
         @excel1.CalculateBeforeSave.should be false
         book.Saved.should be true
@@ -1728,7 +1732,7 @@ module RobustExcelOle
         book = Workbook.open(@simple_file, :visible => true)
         book.Saved.should be true
         @excel1.calculation = :automatic
-        @excel1.calculation.should == :automatic
+        @excel1.properties[:calculation].should == :automatic
         @excel1.Calculation.should == XlCalculationAutomatic
         @excel1.CalculateBeforeSave.should be false
         book.Saved.should be true
@@ -1741,7 +1745,7 @@ module RobustExcelOle
         book.Saved.should be false
         book.Windows(book.Name).Visible = true
         @excel1.calculation = :manual
-        @excel1.calculation.should == :manual
+        @excel1.properties[:calculation].should == :manual
         @excel1.Calculation.should == XlCalculationManual
         @excel1.CalculateBeforeSave.should be false
         book.Saved.should be false
@@ -1753,7 +1757,7 @@ module RobustExcelOle
         book.sheet(1)[1,1] = "foo"
         book.Saved.should be false
         @excel1.calculation = :automatic
-        @excel1.calculation.should == :automatic
+        @excel1.properties[:calculation].should == :automatic
         @excel1.Calculation.should == XlCalculationAutomatic
         @excel1.CalculateBeforeSave.should be false
         book.Saved.should be false
@@ -1770,7 +1774,7 @@ module RobustExcelOle
         @excel1 = Excel.new
         b = Workbook.open(@simple_file, :visible => true)
         @excel1.Calculation = XlCalculationManual
-        @excel1.calculation.should == :manual
+        @excel1.properties[:calculation].should == :manual
         @excel1.Calculation.should == XlCalculationManual
       end
 
@@ -1778,7 +1782,7 @@ module RobustExcelOle
         @excel1 = Excel.new
         b = Workbook.open(@simple_file, :visible => true)
         @excel1.Calculation = XlCalculationAutomatic
-        @excel1.calculation.should == :automatic
+        @excel1.properties[:calculation].should == :automatic
         @excel1.Calculation.should == XlCalculationAutomatic
       end
 
@@ -1922,14 +1926,14 @@ module RobustExcelOle
         @excel2.Hwnd.should == @excel2.hwnd
       end
 
-      it "should provide the same excel instances" do
-        @excel1.should_not == @excel2
-        excel3 = Excel.hwnd2excel(@excel1.hwnd)
-        excel4 = Excel.hwnd2excel(@excel2.hwnd)
-        @excel1.should == excel3
-        @excel2.should == excel4
-        excel3.should_not == excel4
-      end
+   #   it "should provide the same excel instances" do
+   #     @excel1.should_not == @excel2
+   #     excel3 = Excel.hwnd2excel(@excel1.hwnd)
+   #     excel4 = Excel.hwnd2excel(@excel2.hwnd)
+   #     @excel1.should == excel3
+   #     @excel2.should == excel4
+   #     excel3.should_not == excel4
+   #   end
 
 =begin
       # does not work yet
@@ -2015,242 +2019,6 @@ module RobustExcelOle
 
       end
     end
-
-    context "setting the name of a range" do
-
-       before do
-        @book1 = Workbook.open(@dir + '/another_workbook.xls', :read_only => true, :visible => true)
-        @book1.excel.displayalerts = false
-        @excel1 = @book1.excel
-      end
-
-      after do
-        @book1.close
-      end   
-
-      it "should name an unnamed range with a giving address" do
-        @excel1.add_name("foo",[1,2])
-        @excel1.Names.Item("foo").Name.should == "foo"
-        @excel1.Names.Item("foo").Value.should == "=Sheet1!$B$1:$B$1"
-      end
-
-      it "should rename an already named range with a giving address" do
-        @excel1.add_name("foo",[1,1])
-        @excel1.Names.Item("foo").Name.should == "foo"
-        @excel1.Names.Item("foo").Value.should == "=Sheet1!$A$1:$A$1"
-      end
-
-      it "should raise an error" do
-        expect{
-          @excel1.add_name("foo", [-2, 1])
-        }.to raise_error(RangeNotEvaluatable, /cannot add name "foo" to range/)
-      end
-
-      it "should rename a range" do
-        @excel1.add_name("foo",[1,1])
-        @excel1.rename_range("foo","bar")
-        @excel1.namevalue_glob("bar").should == "foo"
-      end
-
-      it "should delete a name of a range" do
-        @excel1.add_name("foo",[1,1])
-        @excel1.delete_name("foo")
-        expect{
-          @excel1.namevalue_glob("foo")
-        }.to raise_error(NameNotFound, /name "foo"/)
-      end
-
-      it "should add a name of a rectangular range" do
-        @excel1.add_name("foo",[1..3,1..4])
-        @excel1["foo"].should == [["foo", "workbook", "sheet1", nil], ["foo", 1.0, 2.0, 4.0], ["matz", 3.0, 4.0, 4.0]] 
-      end
-
-      it "should accept the old interface" do
-        @excel1.add_name("foo",1..3,1..4)
-        @excel1["foo"].should == [["foo", "workbook", "sheet1", nil], ["foo", 1.0, 2.0, 4.0], ["matz", 3.0, 4.0, 4.0]] 
-      end
-
-      it "should add a name of an infinite row range" do
-        @excel1.add_name("foo",[1..3, nil])
-        @excel1.Names.Item("foo").Value.should == "=Sheet1!$1:$3"
-      end
-
-      it "should add a name of an infinite column range" do
-        @excel1.add_name("foo",[nil, "A".."C"])
-        @excel1.Names.Item("foo").Value.should == "=Sheet1!$A:$C"
-      end
-
-      it "should add a name of an infinite row range" do
-        @excel1.add_name("foo",[nil, 1..3])
-        @excel1.Names.Item("foo").Value.should == "=Sheet1!$A:$C"
-      end
-
-      it "should add a name of an infinite column range" do
-        @excel1.add_name("foo",["A:C"])
-        @excel1.Names.Item("foo").Value.should == "=Sheet1!$A:$C"
-      end
-
-      it "should add a name of an infinite column range" do
-        @excel1.add_name("foo",["1:2"])
-        @excel1.Names.Item("foo").Value.should == "=Sheet1!$1:$2"
-      end
-
-    end
-  
-
-    describe "namevalue_glob, set_namevalue_glob" do
-
-      before do
-        @book1 = Workbook.open(@dir + '/another_workbook.xls')
-        @book1.Windows(@book1.Name).Visible = true
-        @excel1 = @book1.excel
-      end
-
-      after do
-        @book1.close(:if_unsaved => :forget)
-      end   
-
-      it "should return value of a defined name" do
-        @excel1.namevalue_glob("firstcell").should == "foo"
-        @excel1["firstcell"].should == "foo"
-      end        
-
-      #it "should evaluate a formula" do
-      #  @excel1.namevalue_glob("named_formula").should == 4
-      #  @excel1["named_formula"].should == 4
-      #end
-
-      it "should raise an error if name not defined" do
-        expect {
-          @excel1.namevalue_glob("foo")
-        }.to raise_error(NameNotFound, /name "foo"/)
-        expect {
-        @excel1["foo"]
-        }.to raise_error(NameNotFound, /name "foo"/)
-        expect {
-          excel2 = Excel.create
-          excel2.namevalue_glob("one")
-        }.to raise_error(NameNotFound, /name "one"/)
-        expect {
-          excel3 = Excel.create(:visible => true)
-          excel3["one"]
-        }.to raise_error(NameNotFound, /name "one"/)
-      end
-
-      it "should set a range to a value" do
-        @excel1.namevalue_glob("firstcell").should == "foo"
-        @excel1.set_namevalue_glob("firstcell","bar")
-        @excel1.namevalue_glob("firstcell").should == "bar"
-        @excel1["firstcell"] = "foo"
-        @excel1.namevalue_glob("firstcell").should == "foo"
-      end
-
-      it "should raise an error if name cannot be evaluated" do
-        expect{
-          @excel1.set_namevalue_glob("foo", 1)
-          }.to raise_error(RangeNotEvaluatable, /cannot assign value to range named "foo"/)
-        expect{
-          @excel1["foo"] = 1
-          }.to raise_error(RangeNotEvaluatable, /cannot assign value to range named "foo"/)
-      end
-
-      it "should color the cell (deprecated)" do
-        @excel1.set_namevalue_glob("firstcell", "foo")
-        @book1.Names.Item("firstcell").RefersToRange.Interior.ColorIndex.should == -4142 
-        @excel1.set_namevalue_glob("firstcell", "foo", :color => 4)
-        @book1.Names.Item("firstcell").RefersToRange.Interior.ColorIndex.should == 4
-        @excel1["firstcell"].should == "foo"
-        @excel1["firstcell"] = "foo"
-        @excel1.Names.Item("firstcell").RefersToRange.Interior.ColorIndex.should == 42
-        @book1.save
-      end
-
-      it "should color the cell" do
-        @excel1.set_namevalue_glob("firstcell", "foo")
-        @book1.Names.Item("firstcell").RefersToRange.Interior.ColorIndex.should == -4142 
-        @book1.color_if_modified = 4
-        @excel1.set_namevalue_glob("firstcell", "foo")
-        @book1.Names.Item("firstcell").RefersToRange.Interior.ColorIndex.should == 4
-        @excel1["firstcell"].should == "foo"
-        @excel1["firstcell"] = "foo"
-        @excel1.Names.Item("firstcell").RefersToRange.Interior.ColorIndex.should == 42
-        @book1.save
-      end
-
-
-    end
-
-    describe "namevalue, set_namevalue" do
-      
-      before do
-        @book1 = Workbook.open(@another_simple_file)
-        @excel1 = @book1.excel
-        # for some reason the workbook must be visible
-        @book1.visible = true
-      end
-
-      after do
-        @book1.close(:if_unsaved => :forget)
-      end   
-
-      it "should return value of a locally defined name" do
-        @excel1.namevalue("firstcell").should == "foo"          
-      end        
-
-      it "should return value of a defined name" do
-        @excel1.namevalue("new").should == "foo"         
-        @excel1.namevalue("one").should == 1.0    
-        @excel1.namevalue("four").should == [[1,2],[3,4]]
-        @excel1.namevalue("firstrow").should == [[1,2]]
-      end    
-
-      it "should return default value if name not defined and default value is given" do
-        @excel1.namevalue("foo", :default => 2).should == 2
-      end
-
-      it "should raise an error if name not defined for the sheet" do
-        expect {
-          @excel1.namevalue("foo")
-          }.to raise_error(NameNotFound, /name "foo" not in/)
-        expect {
-          @excel1.namevalue("named_formula")
-          }.to raise_error(NameNotFound, /name "named_formula" not in/)
-        expect {
-          excel2 = Excel.create
-          excel2.namevalue("one")
-        }.to raise_error(NameNotFound, /name "one" not in/)
-      end
-    
-      it "should set a range to a value" do
-        @excel1.namevalue("firstcell").should == "foo"
-        @excel1.set_namevalue("firstcell","bar")
-        @excel1.namevalue("firstcell").should == "bar"
-      end
-
-      it "should raise an error if name cannot be evaluated" do
-        expect{
-          @excel1.set_namevalue_glob("foo", 1)
-        }.to raise_error(RangeNotEvaluatable, /cannot assign value to range named "foo" in/)
-      end
-
-      it "should color the cell (depracated)" do
-        @excel1.set_namevalue("firstcell", "foo")
-        @book1.Names.Item("firstcell").RefersToRange.Interior.ColorIndex.should == -4142 
-        @excel1.set_namevalue("firstcell", "foo", :color => 4)
-        @book1.Names.Item("firstcell").RefersToRange.Interior.ColorIndex.should == 4
-      end
-
-      it "should color the cell" do
-        @excel1.set_namevalue("firstcell", "foo")
-        @book1.Names.Item("firstcell").RefersToRange.Interior.ColorIndex.should == -4142 
-        @book1.color_if_modified = 4
-        @excel1.set_namevalue("firstcell", "foo")
-        @book1.Names.Item("firstcell").RefersToRange.Interior.ColorIndex.should == 4
-      end
-
-
-    end
-
   end
 end