robust_excel_ole 1.31 → 1.32

data/spec/worksheet_spec.rb

@@ -24,7 +24,7 @@ describe Worksheet do
     @blank_file = @dir + '/book_with_blank.xls'
     @merge_file = @dir + '/merge_cells.xls'
     @listobject_file = @dir + '/workbook_listobjects.xlsx'    
-    @book = Workbook.open(@simple_file)
+    @book = Workbook.open(@simple_file, v: true)
     @sheet = @book.sheet(1)
   end
 
@@ -119,55 +119,352 @@ describe Worksheet do
 
   end
     
-  describe "access sheet name" do
-    describe "#name" do
-      it 'get sheet1 name' do
-        @sheet.name.should eq 'Sheet1'
-      end
+  describe "get and access sheet name" do
+    
+    it 'get sheet1 name' do
+      @sheet.name.should eq 'Sheet1'
+    end
+    
+    it 'change sheet1 name to foo' do
+      @sheet.name = 'foo'
+      @sheet.name.should eq 'foo'
     end
 
-    describe "#name=" do
-      
-      it 'change sheet1 name to foo' do
-        @sheet.name = 'foo'
-        @sheet.name.should eq 'foo'
+    it "should raise error when adding the same name" do
+      @sheet.name = 'foo'
+      @sheet.name.should eq 'foo'
+      new_sheet = @book.add_sheet @sheet
+      expect{
+        new_sheet.name = 'foo'
+      }.to raise_error(NameAlreadyExists, /sheet name "foo" already exists/)
+    end
+
+    it "should get and set name with umlaut" do
+      @sheet.name = "Straße"
+      @sheet.name.should == "Straße"
+    end
+
+    it "should set and get numbers as name" do
+      @sheet.name = 1
+      @sheet.name.should == "1"
+    end
+
+  end
+
+  describe "#[]" do
+
+    it "should yield values of a rectangular range [1..2,1..3]" do
+      value1 = [["foo", "workbook", "sheet1"], ["foo", nil, "foobaaa"]] 
+      @sheet[1..2,1..3].should == value1
+      @sheet[1..2, "A".."C"].should == value1
+      @sheet["A1:C2"].should == value1
+      @sheet["Z1S1:Z2S3"].should == value1
+    end
+
+    it "should yield values of a range [1,1..3]" do
+      @sheet[1,1..3].should == [["foo", "workbook", "sheet1"]]
+    end
+
+    it "should yield values of range [1..2,1]" do
+      @sheet[1..2,1].should == [["foo"], ["foo"]]
+    end
+
+    it "should yield values of row 1" do
+      @sheet[1].should == [["foo", "workbook", "sheet1"]]
+    end
+
+    it "should yield value of a cell [1,2]" do
+      @sheet[1,2].should == "workbook"
+      @sheet["Z1S2"].should == @sheet[1,2]
+      @sheet["B1"].should == @sheet[1,2]
+    end
+
+    it "should a range with relative r1c1-reference" do
+      @sheet.range([1,1]).Select
+      @sheet["Z1S[3]:Z[2]S8"].should == @sheet["Z1S4:Z3S8"]
+    end
+
+    it "should a range with relative integer-range-reference" do
+      @sheet.range([1,1]).Select
+      @sheet[1..[2],[3]..8].should == @sheet["Z1S4:Z3S8"]
+    end
+
+    it "should return value of a defined name" do
+      @book2 = Workbook.open(@dir + '/another_workbook.xls')
+      @sheet2 = @book2.sheet(1)
+      @sheet2["firstcell"].should == "foo"
+      @sheet2["new"].should == "foo"         
+      @sheet2["one"].should == 1.0    
+      @sheet2["four"].should == [[1,2],[3,4]]
+      @sheet2["firstrow"].should == [[1,2]]
+      @sheet2["another"].should == nil
+      expect {
+        @sheet2["foo"]
+      }.to raise_error(RangeNotCreated)  
+      @book2.close(:if_unsaved => :forget)
+    end
+
+  end
+
+  describe "#[]=" do
+
+      before do
+        @book1 = Workbook.open(@dir + '/another_workbook.xls')
+        @sheet1 = @book1.sheet(1)
+      end
+
+      after do
+        @book1.close(:if_unsaved => :forget)
+      end   
+
+      it "should set value of a defined name" do
+        @sheet1["firstcell"].should == "foo"
+        @sheet1["firstcell"] = "bar"
+        @sheet1["firstcell"].should == "bar"
+      end
+
+      it "should set value of a defined name with several values" do
+        @sheet1["four"].should == [[1,2],[3,4]]
+        @sheet1["four"] = [[4,3],[2,1]]
+        @sheet1["four"].should == [[4,3],[2,1]]
+      end  
+
+      it "should set value of a defined name with one value" do
+        @sheet1["four"].should == [[1,2],[3,4]]
+        @sheet1["four"] = 2
+        @sheet1["four"].should == [[2,2],[2,2]]
+      end
+
+      it "should set value given an address" do
+        @sheet1[1..2,1..3].should == [["foo", "workbook", "sheet1"], ["foo", 1.0, 2.0]]
+        @sheet1[1..2,1..3] = [["foo", 1.0, 2.0], ["foo", "workbook", "sheet1"]]
+        @sheet1[1..2,1..3].should == [["foo", 1.0, 2.0], ["foo", "workbook", "sheet1"]]
+      end  
+
+      it "should return nil for a range with empty contents" do
+        @sheet1["another"].should == nil
+      end 
+
+      #it "should evaluate named formula" do
+      #  @sheet1["named_formula"].should == 4
+      #end                
+
+      #it "should evaluate a formula" do
+      #  @sheet1["another_formula"].should == 5
+      #end      
+
+      it "should raise an error if name not defined" do
+        expect {
+          @sheet1["foo"]
+        }.to raise_error(RangeNotCreated, /cannot find name or address "foo"/)        
       end
 
-      it "should raise error when adding the same name" do
-        @sheet.name = 'foo'
-        @sheet.name.should eq 'foo'
-        new_sheet = @book.add_sheet @sheet
+      it "should set a range to a value" do
+        @sheet1[1,1].should == "foo"
+        @sheet1["firstcell"] = "bar"
+        @sheet1[1,1].should == "bar"
+        @sheet1["new"] = "bar"
+        @sheet1["new"].should == "bar"
+      end
+
+      it "should raise an error if name cannot be evaluated" do
         expect{
-          new_sheet.name = 'foo'
-        }.to raise_error(NameAlreadyExists, /sheet name "foo" already exists/)
+          @sheet1["foo"] = 1
+          }.to raise_error(RangeNotEvaluatable, /cannot assign value to range with name or address "foo"/)
       end
     end
-  end
 
-  describe 'access cell' do
+  describe 'access values of cells' do
 
     describe "#[,]" do      
 
-      context "access [1,1]" do
+      context "access values of [1,1]" do
 
-        it { @sheet[1, 1].should be_kind_of Cell }
-        it { @sheet[1, 1].Value.should eq 'foo' }
+        it { @sheet[1, 1].should eq 'foo' }
       end
 
-      context "access [1, 1], [1, 2], [3, 1]" do
+      context "access values of [1, 1], [1, 2], [3, 1]" do
         it "should get every values" do
-          @sheet[1, 1].Value.should eq 'foo'
-          @sheet[1, 2].Value.should eq 'workbook'
-          @sheet[3, 1].Value.should eq 'matz'
+          @sheet[1, 1].should eq 'foo'
+          @sheet[1, 2].should eq 'workbook'
+          @sheet[3, 1].should eq 'matz'
         end
       end
 
-     # context "supplying nil as parameter" do
-     #   it "should access [1,1]" do
-     #     @sheet[1, nil].Value.should eq 'foo'
-     #     @sheet[nil, 1].Value.should eq 'foo'
-     #   end
-     # end
+    end
+
+    describe "namevalue_global, set_namevalue_global" do
+
+      before do
+        @book1 = Workbook.open(@dir + '/another_workbook.xls')
+        @sheet1 = @book1.sheet(1)
+      end
+
+      after do
+        @book1.close(:if_unsaved => :forget)
+      end   
+
+      it "should return value of a defined name" do
+        @sheet1.namevalue_global("firstcell").should == "foo"
+      end
+
+      #it "should evaluate a formula" do
+      #  @sheet1.namevalue_global("another_formula").should == 5
+      #end      
+
+      it "should raise an error if name not defined" do
+        expect {
+          @sheet1.namevalue_global("foo")
+        }.to raise_error(NameNotFound, /name "foo" not in/)
+      end
+
+      it "should raise an error of coordinates are given instead of a defined name" do
+        expect {
+          @sheet1.namevalue_global("A1")
+        }.to raise_error(NameNotFound, /name "A1" not in/)
+      end
+
+      it "should return default value for a range with empty contents" do
+        @sheet1.namevalue_global("another", :default => 2) == 2
+      end 
+
+      it "should set a range to a value" do
+        @sheet1.namevalue_global("firstcell").should == "foo"
+        @sheet1[1,1].should == "foo"
+        @sheet1.set_namevalue_global("firstcell","bar")
+        @sheet1.namevalue_global("firstcell").should == "bar"
+        @sheet1[1,1].should == "bar"
+      end
+
+      it "should raise an error if name cannot be evaluated" do
+        expect{
+          @sheet1.set_namevalue_global("foo", 1)
+        }.to raise_error(RangeNotEvaluatable, /cannot assign value/)
+      end
+
+      it "should color the cell (deprecated)" do
+        @sheet1.set_namevalue_global("new", "bar")
+        @book1.Names.Item("new").RefersToRange.Interior.ColorIndex.should == -4142
+        @sheet1.set_namevalue_global("new", "bar", :color => 4)
+        @book1.Names.Item("new").RefersToRange.Interior.ColorIndex.should == 4
+      end
+
+      it "should color the cell" do
+        @sheet1.set_namevalue_global("new", "bar")
+        @book1.Names.Item("new").RefersToRange.Interior.ColorIndex.should == -4142
+        @sheet1.set_namevalue_global("new", "bar", :color => 4)
+        @book1.Names.Item("new").RefersToRange.Interior.ColorIndex.should == 4
+      end
+
+      it "should set a range to a value with umlauts" do
+        @sheet1.add_name("lösung", [1,1])
+        @sheet1.namevalue_global("lösung").should == "foo"
+        @sheet1[1,1].should == "foo"
+        @sheet1.set_namevalue_global("lösung","bar")
+        @sheet1.namevalue_global("lösung").should == "bar"
+        @sheet1[1,1].should == "bar"  
+      end
+
+    end
+
+    describe "namevalue, set_namevalue" do
+      
+      before do
+        @book1 = Workbook.open(@dir + '/another_workbook.xls')
+        @sheet1 = @book1.sheet(1)
+        @sheet2 = @book1.sheet(2)
+      end
+
+      after do
+        @book1.close(:if_unsaved => :forget)
+      end   
+
+      it "should return value of a locally defined name" do
+        @sheet1.namevalue("firstcell").should == "foo"          
+      end        
+
+      it "should return value of a name with coordinates" do
+        @sheet1.namevalue("A1").should == "foo"         
+      end  
+
+      it "should return nil for a range with empty contents" do
+        @sheet1.namevalue("another").should == nil
+      end 
+
+      it "should return value of a defined name" do
+        @sheet1.namevalue("new").should == "foo"         
+        @sheet1.namevalue("one").should == 1.0    
+        @sheet1.namevalue("four").should == [[1,2],[3,4]]
+        @sheet1.namevalue("firstrow").should == [[1,2]]
+      end    
+
+      it "should return default value if name not defined and default value is given" do
+        @sheet1.namevalue("foo", :default => 2).should == 2
+      end
+
+      it "should raise an error if name not defined for the sheet" do
+        expect {
+          @sheet1.namevalue("foo")
+          }.to raise_error(NameNotFound, /name "foo" not in #<Worksheet: Sheet1/)
+        expect {
+          @sheet1.namevalue("named_formula")
+          }.to raise_error(NameNotFound, /name "named_formula" not in #<Worksheet: Sheet1/)
+        expect {
+          @sheet2.namevalue("firstcell")
+          }.to raise_error(NameNotFound, /name "firstcell" not in #<Worksheet: Sheet2/)
+      end
+    
+      it "should set a range to a value" do
+        @sheet1.namevalue("firstcell").should == "foo"
+        @sheet1[1,1].should == "foo"
+        @sheet1.set_namevalue("firstcell","bar")
+        @sheet1.namevalue("firstcell").should == "bar"
+        @sheet1[1,1].should == "bar"          
+      end
+
+      it "should set a range to a value with umlauts" do
+        @sheet1.add_name("lösung", [1,1])
+        @sheet1.namevalue("lösung").should == "foo"
+        @sheet1[1,1].should == "foo"
+        @sheet1.set_namevalue("lösung","bar")
+        @sheet1.namevalue("lösung").should == "bar"
+        @sheet1[1,1].should == "bar"  
+      end
+
+      it "should raise an error if name cannot be evaluated" do
+        expect{
+          @sheet1.set_namevalue_global("foo", 1)
+        }.to raise_error(RangeNotEvaluatable, /cannot assign value/)
+      end
+
+      it "should raise an error if name not defined and default value is not provided" do
+        expect {
+          @sheet1.namevalue("foo", :default => nil)
+        }.to_not raise_error
+        expect {
+          @sheet1.namevalue("foo", :default => :__not_provided)
+        }.to raise_error(NameNotFound, /name "foo" not in #<Worksheet: Sheet1/)
+        expect {
+          @sheet1.namevalue("foo")
+        }.to raise_error(NameNotFound, /name "foo" not in #<Worksheet: Sheet1/)
+        @sheet1.namevalue("foo", :default => nil).should be_nil
+        @sheet1.namevalue("foo", :default => 1).should == 1
+        @sheet1.namevalue_global("empty", :default => 1).should be_nil
+      end
+
+      it "should color the cell (depracated)" do
+        @sheet1.set_namevalue("new", "bar")
+        @book1.Names.Item("new").RefersToRange.Interior.ColorIndex.should == -4142
+        @sheet1.set_namevalue("new", "bar", :color => 4)
+        @book1.Names.Item("new").RefersToRange.Interior.ColorIndex.should == 4
+      end
+
+      it "should color the cell" do
+        @sheet1.set_namevalue("new", "bar")
+        @book1.Names.Item("new").RefersToRange.Interior.ColorIndex.should == -4142
+        @sheet1.set_namevalue("new", "bar", :color => 4)
+        @book1.Names.Item("new").RefersToRange.Interior.ColorIndex.should == 4
+      end
 
     end
 
@@ -180,18 +477,18 @@ describe Worksheet do
 
     it "change a cell to 'bar'" do
       @sheet[1, 1] = 'bar'
-      @sheet[1, 1].Value.should eq 'bar'
+      @sheet[1, 1].should eq 'bar'
     end
 
     it "should change a cell to nil" do
       @sheet[1, 1] = nil
-      @sheet[1, 1].Value.should eq nil
+      @sheet[1, 1].should eq nil
     end
 
     it "should raise error for bad ranges" do
       expect{
         @sheet[0,0]
-      }.to raise_error(RangeNotEvaluatable, "cannot read cell (0,0)")
+      }.to raise_error(RangeNotCreated, /cannot find name or address 0, 0/)
       expect{
         @sheet[0,0] = "foo"
       }.to raise_error(RangeNotEvaluatable, /cannot assign value/)
@@ -202,16 +499,97 @@ describe Worksheet do
       it "should set color" do
         @sheet.set_cellval(1,1,"foo",:color => 42)
         @sheet.cellval(1,1).should == "foo"
-        @sheet[1,1].Interior.ColorIndex.should == 42
+        @sheet.range([1,1]).Interior.ColorIndex.should == 42
       end
     end
 
-    describe "range" do
+    describe "#range" do
+
+      it "should access a rectangular range [1..2,1..3]" do
+        range1 = @sheet.range(1..2,1..3)
+        range1.should be_kind_of RobustExcelOle::Range
+        range1.Address.should == "$A$1:$C$2"
+        range1.Value.should == [["foo", "workbook", "sheet1"], ["foo", nil, "foobaaa"]]
+        range2 = @sheet.range(1..2, "A".."C")
+        range2.Address.should == range1.Address
+        range3 = @sheet.range("A1:C2")
+        range3.Address.should == range1.Address
+        range4 = @sheet.range(["A1:C2"])
+        range4.Address.should == range1.Address
+        range5 = @sheet.range("Z1S1:Z2S3")
+        range5.Address.should == range1.Address
+        range6 = @sheet.range([1..2,1..3])
+        range6.should be_kind_of RobustExcelOle::Range
+        range6.Address.should == "$A$1:$C$2"
+        range6.Value.should == [["foo", "workbook", "sheet1"], ["foo", nil, "foobaaa"]]
+        range7 = @sheet.range([1..2, "A".."C"])
+        range7.Address.should == range1.Address
+      end
+
+      it "should access a range [1,1..3]" do
+        range1 = @sheet.range(1,1..3)
+        range1.should be_kind_of RobustExcelOle::Range
+        range1.Address.should == "$A$1:$C$1"
+        range1.Value.should == [["foo", "workbook", "sheet1"]]
+        range2 = @sheet.range([1,1..3])
+        range2.Address.should == range1.Address
+      end
+
+      it "should access a range [1..2,1]" do
+        range1 = @sheet.range(1..2,1)
+        range1.should be_kind_of RobustExcelOle::Range
+        range1.Address.should == "$A$1:$A$2"
+        range1.Value.should == [["foo"], ["foo"]]
+        range2 = @sheet.range([1..2,1])
+        range2.Address.should == range1.Address
+      end
+
+      it "should access a row 1" do
+        range1 = @sheet.range(1)
+        range1.should be_kind_of RobustExcelOle::Range
+        range1.Address.should == "$1:$1"
+        range1.Value.first.size.should == 256
+        range1.value.should == [["foo", "workbook", "sheet1"]]
+        range2 = @sheet.range([1])
+        range2.Address.should == range1.Address
+      end
+
+      it "should access several rows" do
+        @sheet.range([1..3]).Address.should == "$1:$3"
+        @sheet.range(1..3).Address.should == "$1:$3"
+        @sheet.range([1..3,nil]).Address.should == "$1:$3"
+        @sheet.range(1..3,nil).Address.should == "$1:$3"
+      end
+
+      it "should access several columns" do
+        @sheet.range([nil,2..4]).Address.should == "$B:$D"
+        @sheet.range(nil,2..4).Address.should == "$B:$D"
+        @sheet.range([nil,"B".."D"]).Address.should == "$B:$D"
+        @sheet.range(nil,"B".."D").Address.should == "$B:$D"
+      end
+
+      it "should create infinite ranges" do
+        @sheet.range("1:3").Address.should == "$1:$3"
+        @sheet.range("B:D").Address.should == "$B:$D"
+      end
+
+      it "should access a cell [1,2]" do
+        cell1 = @sheet.range(1,2)
+        cell1.should be_kind_of Cell
+        cell1.Address.should == "$B$1"
+        cell1.Value.should == "workbook"
+        cell2 = @sheet.range("B1")
+        cell1.should be_kind_of Cell
+        cell2.Address.should == cell1.Address
+        cell3 = @sheet.range("Z1S2")
+        cell1.should be_kind_of Cell
+        cell3.Address.should == cell1.Address
+      end
 
       it "should a range with relative r1c1-reference" do
         @sheet.range([1,1]).Select
-        @sheet.range(["Z1S[3]:Z[2]S8"]).Address.should == "$D$1:$H$3"
-        @sheet.range(["Z1S3:Z2S8"]).Address.should == "$C$1:$H$2"
+        @sheet.range("Z1S[3]:Z[2]S8").Address.should == "$D$1:$H$3"
+        @sheet.range("Z1S3:Z2S8").Address.should == "$C$1:$H$2"
       end
 
       it "should a range with relative integer-range-reference" do
@@ -219,39 +597,42 @@ describe Worksheet do
         @sheet.range([1..[2],[3]..8]).Address.should == "$D$1:$H$3"
       end
 
-      it "should create a range of one cell" do
-        @sheet.range([1,2]).values.should == ["workbook"]
-        @sheet.range(["B1"]).values.should == ["workbook"]
-        @sheet.range("B1").values.should == ["workbook"]
-        @sheet.range(["Z1S2"]).values.should == ["workbook"]
-        @sheet.range("Z1S2").values.should == ["workbook"]
+      it "should raise an error" do
+        expect{
+          @sheet.range([0,0])
+        }.to raise_error(RangeNotCreated, /cannot find/)
+        expect{
+          @sheet.range([0..3,4])
+        }.to raise_error(RangeNotCreated, /cannot find/)
+      end
+
+      it "should return value of a defined name" do
+        @book2 = Workbook.open(@dir + '/another_workbook.xls')
+        @sheet2 = @book2.sheet(1)
+        range1 = @sheet2.range("firstcell")
+        range1.should be_kind_of Cell
+        range1.Value.should == "foo"
+        @sheet2.range("new").Value.should == "foo"         
+        @sheet2.range("one").Value.should == 1.0    
+        @sheet2.range("four").Value.should == [[1,2],[3,4]]
+        @sheet2.range("firstrow").Value.should == [[1,2]]
+        @sheet2.range("another").Value.should == nil
+        expect {
+          @sheet2.range("foo")
+        }.to raise_error(RangeNotCreated)  
+        @book2.close(:if_unsaved => :forget)
       end
 
       it "should create a rectangular range" do
         @sheet.range([1..3,2..4]).values.should == ["workbook", "sheet1", nil, nil, "foobaaa", nil, "is", "nice", nil]
         @sheet.range([1..3, "B".."D"]).values.should == ["workbook", "sheet1", nil, nil, "foobaaa", nil, "is", "nice", nil]     
-        @sheet.range(["B1:D3"]).values.should == ["workbook", "sheet1", nil, nil, "foobaaa", nil, "is", "nice", nil]
         @sheet.range("B1:D3").values.should == ["workbook", "sheet1", nil, nil, "foobaaa", nil, "is", "nice", nil]
-        @sheet.range(["Z1S2:Z3S4"]).values.should == ["workbook", "sheet1", nil, nil, "foobaaa", nil, "is", "nice", nil]
         @sheet.range("Z1S2:Z3S4").values.should == ["workbook", "sheet1", nil, nil, "foobaaa", nil, "is", "nice", nil]
       end
-
-      it "should accept old interface" do
-        @sheet.range(1..3,2..4).values.should == ["workbook", "sheet1", nil, nil, "foobaaa", nil, "is", "nice", nil]
-        @sheet.range(1..3, "B".."D").values.should == ["workbook", "sheet1", nil, nil, "foobaaa", nil, "is", "nice", nil]     
-      end
-
-      it "should create infinite ranges" do
-        @sheet.range([1..3,nil]).Address.should == "$1:$3"
-        @sheet.range(nil,"B".."D").Address.should == "$B:$D"
-        @sheet.range("1:3").Address.should == "$1:$3"
-        @sheet.range("B:D").Address.should == "$B:$D"
-      end
-
-      it "should raise an error" do
-        expect{
-          @sheet.range([0,0])
-          }.to raise_error(RangeNotCreated, /cannot create/)
+
+      it "should accept old interface" do
+        @sheet.range(1..3,2..4).values.should == ["workbook", "sheet1", nil, nil, "foobaaa", nil, "is", "nice", nil]
+        @sheet.range(1..3, "B".."D").values.should == ["workbook", "sheet1", nil, nil, "foobaaa", nil, "is", "nice", nil]     
       end
 
     end
@@ -267,16 +648,23 @@ describe Worksheet do
         table = @sheet.table(1)
         table.Name.should == "table3"
         table.HeaderRowRange.Value.first.should == ["Number","Person","Amount","Time","Price"]
-        table.ListRows.Count.should == 6
-        @sheet[3,4].Value.should == "Number"
+        table.ListRows.Count.should == 13
+        @sheet[3,4].should == "Number"
       end
 
       it "should yield table given name" do
         table = @sheet.table("table3")
         table.Name.should == "table3"
         table.HeaderRowRange.Value.first.should == ["Number","Person","Amount","Time","Price"]
-        table.ListRows.Count.should == 6
-        @sheet[3,4].Value.should == "Number"
+        table.ListRows.Count.should == 13
+        @sheet[3,4].should == "Number"
+      end
+
+      it "should yield table given name with umlauts" do
+        table = Table.new(@sheet, "lösung", [1,1], 3, ["Verkäufer","Straße"])
+        table2 = @sheet.table("lösung")
+        table2.Name.encode_value.should == "lösung"
+        table2.HeaderRowRange.Value.first.encode_value.should == ["Verkäufer","Straße"]
       end
 
       it "should raise error" do
@@ -287,9 +675,10 @@ describe Worksheet do
 
     end
 
-    describe '#each' do
+    describe '#each_cell' do
+
       it "should sort line in order of column" do
-        @sheet.each_with_index do |cell, i|
+        @sheet.each_cell.with_index do |cell, i|
           case i
           when 0
             cell.Value.should eq 'foo'
@@ -311,7 +700,7 @@ describe Worksheet do
         include_context "sheet 'open book with blank'"
 
         it 'should get from ["A1"]' do
-          @sheet_with_blank.each_with_index do |cell, i|
+          @sheet_with_blank.each_cell.with_index do |cell, i|
             case i
             when 5
               cell.Value.should be_nil
@@ -328,6 +717,16 @@ describe Worksheet do
         end
       end
 
+      it "should access each cell" do
+        cells = []
+        @sheet.each_cell do |cell|
+          cells << cell
+        end
+        cells.should == [@sheet.range(1,1), @sheet.range(1,2), @sheet.range(1,3),
+                         @sheet.range(2,1), @sheet.range(2,2), @sheet.range(2,3),
+                         @sheet.range(3,1), @sheet.range(3,2), @sheet.range(3,3)]
+      end
+
     end
 
     describe "#values" do
@@ -338,6 +737,35 @@ describe Worksheet do
 
     end
 
+    describe "#names" do
+
+      before do
+        @book1 = Workbook.open(@dir + '/another_workbook.xls')
+        @sheet1 = @book1.sheet(1)
+      end
+
+      it "should yield defined names" do
+        @sheet1.names.should == ["Sheet1!another_formula", "Sheet1!firstcell", "Sheet1!localname", "Sheet1!simple"]
+      end
+      
+    end
+
+    describe "#each" do
+
+      it "should yield rows" do
+        @sheet.each.with_index do |row, i|
+          row.should == ["foo", "workbook", "sheet1"] if i == 0
+          row.should == ["foo", nil, "foobaaa"] if i == 1
+          row.should == ["matz", "is", "nice"] if i == 2
+        end
+      end
+
+      it "should do map" do
+        @sheet.map{|r| r}.should == [["foo", "workbook", "sheet1"], ["foo", nil, "foobaaa"], ["matz", "is", "nice"]]
+      end
+
+    end
+
     describe "#each_rowvalue" do
 
       it "should yield arrays" do
@@ -415,9 +843,9 @@ describe Worksheet do
 
     end
 
-    describe "#each_row_with_index" do
+    describe "#each_row.with_index" do
       it "should read with index" do
-        @sheet.each_row_with_index do |rows, idx|
+        @sheet.each_row.with_index do |rows, idx|
           case idx
           when 0
             rows.values.should eq ['foo', 'workbook', 'sheet1']
@@ -429,22 +857,10 @@ describe Worksheet do
         end
       end
 
-      context "with argument 1" do
-        it "should read from second row, index is started 0" do
-          @sheet.each_row_with_index(1) do |rows, idx|
-            case idx
-            when 0
-              rows.values.should eq ['foo', nil, 'foobaaa']
-            when 1
-              rows.values.should eq ['matz', 'is', 'nice']
-            end
-          end
-        end
-      end
-
     end
 
     describe "#each_column" do
+
       it "items should RobustExcelOle::Range" do
         @sheet.each_column do |columns|
           columns.should be_kind_of RobustExcelOle::Range
@@ -511,8 +927,9 @@ describe Worksheet do
     end
 
     describe "#each_column_with_index" do
+   
       it "should read with index" do
-        @sheet.each_column_with_index do |columns, idx|
+        @sheet.each_column.with_index do |columns, idx|
           case idx
           when 0
             columns.values.should eq ['foo', 'foo', 'matz']
@@ -523,19 +940,6 @@ describe Worksheet do
           end
         end
       end
-
-      context "with argument 1" do
-        it "should read from second column, index is started 0" do
-          @sheet.each_column_with_index(1) do |column_range, idx|
-            case idx
-            when 0
-              column_range.values.should eq ['workbook', nil, 'is']
-            when 1
-              column_range.values.should eq ['sheet1', 'foobaaa', 'nice']
-            end
-          end
-        end
-      end
     end
 
     describe "#row_range" do
@@ -587,222 +991,7 @@ describe Worksheet do
       end
     end
 
-    describe "[], []=" do
-      before do
-        @book1 = Workbook.open(@dir + '/another_workbook.xls')
-        @sheet1 = @book1.sheet(1)
-      end
-
-      after do
-        @book1.close(:if_unsaved => :forget)
-      end   
-
-      it "should return value of a defined name" do
-        @sheet1["firstcell"].should == "foo"
-      end
-
-      it "should return value of a defined name" do
-        @sheet1["new"].should == "foo"         
-        @sheet1["one"].should == 1.0    
-        @sheet1["four"].should == [[1,2],[3,4]]
-        @sheet1["firstrow"].should == [[1,2]]
-      end  
-
-      it "should return value of a name with coordinates" do
-        @sheet1["A1"].should == "foo"         
-      end  
-
-      it "should return nil for a range with empty contents" do
-        @sheet1["another"].should == nil
-      end 
-
-      #it "should evaluate named formula" do
-      #  @sheet1["named_formula"].should == 4
-      #end                
-
-      #it "should evaluate a formula" do
-      #  @sheet1["another_formula"].should == 5
-      #end      
-
-      it "should raise an error if name not defined" do
-        expect {
-          @sheet1["foo"]
-        }.to raise_error(NameNotFound, /name "foo" not in #<Worksheet: Sheet1/)        
-      end
-
-      it "should set a range to a value" do
-        @sheet1[1,1].Value.should == "foo"
-        @sheet1["firstcell"] = "bar"
-        @sheet1[1,1].Value.should == "bar"
-        @sheet1["new"] = "bar"
-        @sheet1["new"].should == "bar"
-      end
-
-      it "should raise an error if name cannot be evaluated" do
-        expect{
-          @sheet1["foo"] = 1
-          }.to raise_error(NameNotFound, /name "foo" not in #<Worksheet: Sheet1/)
-      end
-    end
-
-    describe "namevalue_global, set_namevalue_global" do
-
-      before do
-        @book1 = Workbook.open(@dir + '/another_workbook.xls')
-        @sheet1 = @book1.sheet(1)
-      end
-
-      after do
-        @book1.close(:if_unsaved => :forget)
-      end   
-
-      it "should return value of a defined name" do
-        @sheet1.namevalue_global("firstcell").should == "foo"
-      end
-
-      #it "should evaluate a formula" do
-      #  @sheet1.namevalue_global("another_formula").should == 5
-      #end      
-
-      it "should raise an error if name not defined" do
-        expect {
-          @sheet1.namevalue_global("foo")
-        }.to raise_error(NameNotFound, /name "foo" not in/)
-      end
-
-      it "should raise an error of coordinates are given instead of a defined name" do
-        expect {
-          @sheet1.namevalue_global("A1")
-        }.to raise_error(NameNotFound, /name "A1" not in/)
-      end
-
-      it "should return default value for a range with empty contents" do
-        @sheet1.namevalue_global("another", :default => 2) == 2
-      end 
-
-      it "should set a range to a value" do
-        @sheet1.namevalue_global("firstcell").should == "foo"
-        @sheet1[1,1].Value.should == "foo"
-        @sheet1.set_namevalue_global("firstcell","bar")
-        @sheet1.namevalue_global("firstcell").should == "bar"
-        @sheet1[1,1].Value.should == "bar"
-      end
-
-      it "should raise an error if name cannot be evaluated" do
-        expect{
-          @sheet1.set_namevalue_global("foo", 1)
-        }.to raise_error(RangeNotEvaluatable, /cannot assign value/)
-      end
-
-      it "should color the cell (deprecated)" do
-        @sheet1.set_namevalue_global("new", "bar")
-        @book1.Names.Item("new").RefersToRange.Interior.ColorIndex.should == -4142
-        @sheet1.set_namevalue_global("new", "bar", :color => 4)
-        @book1.Names.Item("new").RefersToRange.Interior.ColorIndex.should == 4
-      end
-
-      it "should color the cell" do
-        @sheet1.set_namevalue_global("new", "bar")
-        @book1.Names.Item("new").RefersToRange.Interior.ColorIndex.should == -4142
-        @sheet1.set_namevalue_global("new", "bar", :color => 4)
-        @book1.Names.Item("new").RefersToRange.Interior.ColorIndex.should == 4
-      end
-
-    end
-
-    describe "namevalue, set_namevalue" do
-      
-      before do
-        @book1 = Workbook.open(@dir + '/another_workbook.xls')
-        @sheet1 = @book1.sheet(1)
-        @sheet2 = @book1.sheet(2)
-      end
-
-      after do
-        @book1.close(:if_unsaved => :forget)
-      end   
-
-      it "should return value of a locally defined name" do
-        @sheet1.namevalue("firstcell").should == "foo"          
-      end        
-
-      it "should return value of a name with coordinates" do
-        @sheet1.namevalue("A1").should == "foo"         
-      end  
-
-      it "should return nil for a range with empty contents" do
-        @sheet1.namevalue("another").should == nil
-      end 
-
-      it "should return value of a defined name" do
-        @sheet1.namevalue("new").should == "foo"         
-        @sheet1.namevalue("one").should == 1.0    
-        @sheet1.namevalue("four").should == [[1,2],[3,4]]
-        @sheet1.namevalue("firstrow").should == [[1,2]]
-      end    
-
-      it "should return default value if name not defined and default value is given" do
-        @sheet1.namevalue("foo", :default => 2).should == 2
-      end
-
-      it "should raise an error if name not defined for the sheet" do
-        expect {
-          @sheet1.namevalue("foo")
-          }.to raise_error(NameNotFound, /name "foo" not in #<Worksheet: Sheet1/)
-        expect {
-          @sheet1.namevalue("named_formula")
-          }.to raise_error(NameNotFound, /name "named_formula" not in #<Worksheet: Sheet1/)
-        expect {
-          @sheet2.namevalue("firstcell")
-          }.to raise_error(NameNotFound, /name "firstcell" not in #<Worksheet: Sheet2/)
-      end
-    
-      it "should set a range to a value" do
-        @sheet1.namevalue("firstcell").should == "foo"
-        @sheet1[1,1].Value.should == "foo"
-        @sheet1.set_namevalue("firstcell","bar")
-        @sheet1.namevalue("firstcell").should == "bar"
-        @sheet1[1,1].Value.should == "bar"          
-      end
-
-      it "should raise an error if name cannot be evaluated" do
-        expect{
-          @sheet1.set_namevalue_global("foo", 1)
-        }.to raise_error(RangeNotEvaluatable, /cannot assign value/)
-      end
-
-      it "should raise an error if name not defined and default value is not provided" do
-        expect {
-          @sheet1.namevalue("foo", :default => nil)
-        }.to_not raise_error
-        expect {
-          @sheet1.namevalue("foo", :default => :__not_provided)
-        }.to raise_error(NameNotFound, /name "foo" not in #<Worksheet: Sheet1/)
-        expect {
-          @sheet1.namevalue("foo")
-        }.to raise_error(NameNotFound, /name "foo" not in #<Worksheet: Sheet1/)
-        @sheet1.namevalue("foo", :default => nil).should be_nil
-        @sheet1.namevalue("foo", :default => 1).should == 1
-        @sheet1.namevalue_global("empty", :default => 1).should be_nil
-      end
-
-      it "should color the cell (depracated)" do
-        @sheet1.set_namevalue("new", "bar")
-        @book1.Names.Item("new").RefersToRange.Interior.ColorIndex.should == -4142
-        @sheet1.set_namevalue("new", "bar", :color => 4)
-        @book1.Names.Item("new").RefersToRange.Interior.ColorIndex.should == 4
-      end
-
-      it "should color the cell" do
-        @sheet1.set_namevalue("new", "bar")
-        @book1.Names.Item("new").RefersToRange.Interior.ColorIndex.should == -4142
-        @sheet1.set_namevalue("new", "bar", :color => 4)
-        @book1.Names.Item("new").RefersToRange.Interior.ColorIndex.should == 4
-      end
-
-    end
-
-    describe "add_name, delete_name, rename_range" do
+    describe "add_name, delete_name, rename_name" do
 
       context "adding, renaming, deleting the name of a range" do
 
@@ -833,7 +1022,7 @@ describe Worksheet do
         end
 
         it "should rename an already named range with a giving address" do
-          @sheet1[1,1].Name.Name.should == "Sheet1!firstcell"
+          @sheet1.range([1,1]).Name.Name.should == "Sheet1!firstcell"
           @sheet1.add_name("foo",[1..2,3..4])
           @sheet1.Range("foo").Address.should == "$C$1:$D$2"
         end
@@ -846,10 +1035,17 @@ describe Worksheet do
 
         it "should rename a range" do
           @sheet1.add_name("foo",[1,1])
-          @sheet1.rename_range("foo","bar")
+          @sheet1.rename_name("foo","bar")
           @sheet1.namevalue_global("bar").should == "foo"
         end
 
+        it "should rename a range with umlauts" do
+          @sheet1.add_name("lösung",[1,1])
+          @sheet1.rename_name("lösung","bär")
+          @sheet1.namevalue_global("bär").should == "foo"
+        end
+
+
         it "should delete a name of a range" do
           @sheet1.add_name("foo",[1,1])
           @sheet1.delete_name("foo")
@@ -858,6 +1054,14 @@ describe Worksheet do
          }.to raise_error(NameNotFound, /name "foo"/)
         end
 
+        it "should delete a name of a range with umlauts" do
+          @sheet1.add_name("lösung",[1,1])
+          @sheet1.delete_name("lösung")
+          expect{
+            @sheet1.namevalue_global("lösung")
+         }.to raise_error(NameNotFound, /name/)
+        end
+
         it "should add a name of a rectangular range" do
           @sheet1.add_name("foo",[1..3,1..4])
           @sheet1["foo"].should == [["foo", "workbook", "sheet1", nil], ["foo", 1.0, 2.0, 4.0], ["matz", 3.0, 4.0, 4.0]]