spreadbase 0.1.2 → 0.3.0

data/lib/spreadbase/version.rb

@@ -1,5 +1,3 @@
-# encoding: UTF-8
-
 module SpreadBase
-  VERSION = "0.1.2"
+  VERSION = "0.3.0"
 end

data/spec/codecs/open_document_12_spec.rb

@@ -1,25 +1,5 @@
-# encoding: UTF-8
-
-=begin
-Copyright 2012 Saverio Miroddi saverio.pub2 <a-hat!> gmail.com
-
-This file is part of SpreadBase.
-
-SpreadBase is free software: you can redistribute it and/or modify it under the
-terms of the GNU Lesser General Public License as published by the Free Software
-Foundation, either version 3 of the License, or (at your option) any later
-version.
-
-SpreadBase is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public License along
-with SpreadBase.  If not, see <http://www.gnu.org/licenses/>.
-=end
-
-require File.expand_path( '../../../lib/spreadbase', __FILE__ )
-require File.expand_path( '../../spec_helpers',      __FILE__ )
+require_relative '../../lib/spreadbase'
+require_relative '../spec_helpers'
 
 require 'date'
 require 'bigdecimal'
@@ -33,13 +13,13 @@ describe SpreadBase::Codecs::OpenDocument12 do
   before :each do
     table_1 = SpreadBase::Table.new(
       'abc', [
-        [ 1,      1.1,        T_BIGDECIMAL ],
-        [ T_DATE, T_DATETIME, T_TIME       ],
-        [ nil,    'a',        nil          ]
+        [1,      1.1,        T_BIGDECIMAL],
+        [T_DATE, T_DATETIME, T_TIME],
+        [nil,    nil,        'a']
       ]
     )
 
-    table_2 = SpreadBase::Table.new( 'cde' )
+    table_2 = SpreadBase::Table.new('cde')
 
     @sample_document = SpreadBase::Document.new
 
@@ -49,89 +29,173 @@ describe SpreadBase::Codecs::OpenDocument12 do
   # :encode/:decode
   #
   it "should encode and decode the sample document" do
-    document_archive = SpreadBase::Codecs::OpenDocument12.new.encode_to_archive( @sample_document )
+    document_archive = SpreadBase::Codecs::OpenDocument12.new.encode_to_archive(@sample_document)
 
-    document = SpreadBase::Codecs::OpenDocument12.new.decode_archive( document_archive, :floats_as_bigdecimal => true )
+    document = SpreadBase::Codecs::OpenDocument12.new.decode_archive(document_archive, floats_as_bigdecimal: true)
 
-    assert_size( document.tables, 2 ) do | table_1, table_2 |
+    assert_size(document.tables, 2) do | table_1, table_2 |
 
-      table_1.name.should == 'abc'
+      expect(table_1.name).to eq('abc')
 
-      assert_size( table_1.data, 3 ) do | row_1, row_2, row_3 |
+      assert_size(table_1.data, 3) do | row_1, row_2, row_3 |
 
-        assert_size( row_1, 3 ) do | value_1, value_2, value_3 |
-          value_1.should == 1
-          value_1.should be_a( Fixnum )
-          value_2.should == 1.1
-          value_2.should be_a( BigDecimal )
-          value_3.should == T_BIGDECIMAL
-          value_3.should be_a( BigDecimal )
+        assert_size(row_1, 3) do | value_1, value_2, value_3 |
+          expect(value_1).to eq(1)
+          expect(value_1).to be_a(Integer)
+          expect(value_2).to eq(1.1)
+          expect(value_2).to be_a(BigDecimal)
+          expect(value_3).to eq(T_BIGDECIMAL)
+          expect(value_3).to be_a(BigDecimal)
         end
 
-        assert_size( row_2, 3 ) do | value_1, value_2, value_3 |
-          value_1.should == T_DATE
-          value_2.should == T_DATETIME
-          value_3.should == T_DATETIME
+        assert_size(row_2, 3) do | value_1, value_2, value_3 |
+          expect(value_1).to eq(T_DATE)
+          expect(value_2).to eq(T_DATETIME)
+          expect(value_3).to eq(T_DATETIME)
         end
 
-        assert_size( row_3, 3 ) do | value_1, value_2, value_3 |
-          value_1.should == nil
-          value_2.should == 'a'
-          value_3.should == nil
+        assert_size(row_3, 3) do | value_1, value_2, value_3 |
+          expect(value_1).to eq(nil)
+          expect(value_2).to eq(nil)
+          expect(value_3).to eq('a')
         end
 
       end
 
-      table_2.name.should == 'cde'
+      expect(table_2.name).to eq('cde')
 
-      assert_size( table_2.data, 0 )
+      assert_size(table_2.data, 0)
     end
   end
 
   # Not worth testing in detail; just ensure that the pref
   #
   it "should encode the document with makeup (:prettify) - SMOKE" do
-    formatter = stub_initializer( REXML::Formatters::Pretty )
+    formatter = stub_initializer(REXML::Formatters::Pretty)
 
-    formatter.should_receive( :write )
+    expect(formatter).to receive(:write)
 
-    SpreadBase::Codecs::OpenDocument12.new.encode_to_archive( @sample_document, :prettify => true )
+    SpreadBase::Codecs::OpenDocument12.new.encode_to_archive(@sample_document, prettify: true)
   end
 
   # Those methods are actually "utility" (read: testing) methods.
   #
   it "should encode/decode the content.xml - SMOKE" do
-    content_xml = SpreadBase::Codecs::OpenDocument12.new.encode_to_content_xml( @sample_document )
+    content_xml = SpreadBase::Codecs::OpenDocument12.new.encode_to_content_xml(@sample_document)
 
-    document = SpreadBase::Codecs::OpenDocument12.new.decode_content_xml( content_xml )
+    document = SpreadBase::Codecs::OpenDocument12.new.decode_content_xml(content_xml)
 
-    assert_size( document.tables, 2 )
+    assert_size(document.tables, 2)
   end
 
   # If values are not converted to UTF-8, some encodings cause an error to be
   # raised when assigning a value to a cell.
   #
-  # 1.8 tests can't be done, since the official platform is 1.9
-  #
   it "should convert to utf-8 before saving" do
-    string = "à".encode( 'UTF-16' )
+    string = "à".encode('utf-16')
 
-    @sample_document.tables[ 0 ][ 0,  0 ] = string
+    @sample_document.tables[0][0,  0] = string
 
     # Doesn't encode correctly if the value is not converted
     #
-    SpreadBase::Codecs::OpenDocument12.new.encode_to_content_xml( @sample_document )
+    SpreadBase::Codecs::OpenDocument12.new.encode_to_content_xml(@sample_document)
   end
 
   it "should decode as BigDecimal" do
-    content_xml = SpreadBase::Codecs::OpenDocument12.new.encode_to_content_xml( @sample_document )
+    content_xml = SpreadBase::Codecs::OpenDocument12.new.encode_to_content_xml(@sample_document)
+
+    document = SpreadBase::Codecs::OpenDocument12.new.decode_content_xml(content_xml, floats_as_bigdecimal: true)
+
+    value = document.tables[0][2, 0]
+
+    expect(value).to be_a(BigDecimal)
+    expect(value).to eq(T_BIGDECIMAL)
+  end
+
+  context "when cells at the end of the row are empty" do
+    let(:document_archive) do
+      document = SpreadBase::Document.new
+
+      document.tables << SpreadBase::Table.new(
+        'abc', [
+          [nil],
+          [nil, nil],
+          [1  , nil],
+          [nil, 1  , nil]
+        ]
+      )
+
+      SpreadBase::Codecs::OpenDocument12.new.encode_to_archive(document)
+    end
+
+    it "should drop such cells" do
+      document = SpreadBase::Codecs::OpenDocument12.new.decode_archive(document_archive)
+      table = document.tables[0]
 
-    document = SpreadBase::Codecs::OpenDocument12.new.decode_content_xml( content_xml, :floats_as_bigdecimal => true )
+      assert_size(table.data, 4) do |row_1, row_2, row_3, row_4|
+        assert_size(row_1, 0)
 
-    value = document.tables[ 0 ][ 2, 0 ]
+        assert_size(row_2, 0)
 
-    value.should be_a( BigDecimal )
-    value.should == T_BIGDECIMAL
+        assert_size(row_3, 1) do |value_1|
+          expect(value_1).to eq(1)
+        end
+
+        assert_size(row_4, 2) do |value_1, value_2|
+          expect(value_1).to be_nil
+          expect(value_2).to eq(1)
+        end
+      end
+    end
+  end
+
+  context "when cells of the last row are empty" do
+    let(:document_archive) do
+      document = SpreadBase::Document.new
+
+      document.tables << SpreadBase::Table.new(
+        'abc', [
+          []
+        ]
+      )
+
+      document.tables << SpreadBase::Table.new(
+        'def', [
+          [nil]
+        ]
+      )
+
+      document.tables << SpreadBase::Table.new(
+        'ghi', [
+          [nil, nil]
+        ]
+      )
+
+      document.tables << SpreadBase::Table.new(
+        'jkl', [
+          [nil],
+          [1],
+          [nil]
+        ]
+      )
+
+      SpreadBase::Codecs::OpenDocument12.new.encode_to_archive(document)
+    end
+
+    it "should drop such row" do
+      document = SpreadBase::Codecs::OpenDocument12.new.decode_archive(document_archive)
+      tables = document.tables
+
+      assert_size(tables, 4) do |table_1, table_2, table_3, table_4|
+        assert_size(table_1.data, 0)
+
+        assert_size(table_2.data, 0)
+
+        assert_size(table_3.data, 0)
+
+        assert_size(table_4.data, 2)
+      end
+    end
   end
 
 end

data/spec/elements/document_spec.rb

@@ -1,25 +1,5 @@
-# encoding: utf-8
-
-=begin
-Copyright 2012 Saverio Miroddi saverio.pub2 <a-hat!> gmail.com
-
-This file is part of SpreadBase.
-
-SpreadBase is free software: you can redistribute it and/or modify it under the
-terms of the GNU Lesser General Public License as published by the Free Software
-Foundation, either version 3 of the License, or (at your option) any later
-version.
-
-SpreadBase is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public License along
-with SpreadBase.  If not, see <http://www.gnu.org/licenses/>.
-=end
-
-require File.expand_path( '../../../lib/spreadbase', __FILE__ )
-require File.expand_path( '../../spec_helpers',      __FILE__ )
+require_relative '../../lib/spreadbase'
+require_relative '../spec_helpers'
 
 include SpecHelpers
 
@@ -30,9 +10,9 @@ describe SpreadBase::Document do
     @sample_document.tables = [
       SpreadBase::Table.new(
         'abc', [
-          [ 1,      1.1,        T_BIGDECIMAL ],
-          [ T_DATE, T_DATETIME, T_TIME       ],
-          [ true,   'a',        nil          ]
+          [1,      1.1,        T_BIGDECIMAL],
+          [T_DATE, T_DATETIME, T_TIME],
+          [true,   'a',        nil]
         ]
       )
     ]
@@ -43,61 +23,59 @@ describe SpreadBase::Document do
   it "should initialize out of thin air" do
     document = SpreadBase::Document.new
 
-    document.document_path.should == nil
+    expect(document.document_path).to be(nil)
 
-    document.tables.should be_empty
+    expect(document.tables).to be_empty
   end
 
   # A lazy use of stubs
   #
   it "should initialize from a file" do
-    codec = stub_initializer( SpreadBase::Codecs::OpenDocument12 )
+    codec = stub_initializer(SpreadBase::Codecs::OpenDocument12)
 
-    File.should_receive( :'exists?' ).with( '/pizza/margerita.txt' ).and_return( true )
-    IO.should_receive( :read ).with( '/pizza/margerita.txt' ).and_return( 'abc' )
-    codec.should_receive( :decode_archive ).with( 'abc', {} ).and_return( @sample_document )
+    expect(File).to receive(:'exist?').with('/pizza/margerita.txt').and_return(true)
+    expect(IO).to receive(:read).with('/pizza/margerita.txt').and_return('abc')
+    expect(codec).to receive(:decode_archive).with('abc', {}).and_return(@sample_document)
 
-    document = SpreadBase::Document.new( '/pizza/margerita.txt' )
+    document = SpreadBase::Document.new('/pizza/margerita.txt')
 
-    assert_size( document.tables, 1 ) do | table |
-      table.name.should == 'abc'
-      table.data.size.should == 3
+    assert_size(document.tables, 1) do | table |
+      expect(table.name).to eq('abc')
+      expect(table.data.size).to eq(3)
     end
   end
 
   it "should initialize with a non-existing file" do
-    codec = stub_initializer( SpreadBase::Codecs::OpenDocument12 )
-
-    document = SpreadBase::Document.new( '/pizza/margerita.txt' )
+    document = SpreadBase::Document.new('/pizza/margerita.txt')
 
-    assert_size( document.tables, 0 )
+    assert_size(document.tables, 0)
   end
 
   it "should save to a file" do
-    codec = stub_initializer( SpreadBase::Codecs::OpenDocument12 )
+    codec = stub_initializer(SpreadBase::Codecs::OpenDocument12)
 
     document = SpreadBase::Document.new
-    document.tables << SpreadBase::Table.new( 'Ya-ha!' )
+    document.tables << SpreadBase::Table.new('Ya-ha!')
     document.document_path = '/tmp/abc.ods'
 
-    codec.should_receive( :encode_to_archive ).with( document, :prettify => 'abc' ).and_return( 'sob!' )
-    File.should_receive( :open ).with( '/tmp/abc.ods', 'wb' )
+    expect(codec).to receive(:encode_to_archive).with(document, prettify: 'abc').and_return('sob!')
+    expect(File).to receive(:open).with('/tmp/abc.ods', 'wb')
 
-    document.save( :prettify => 'abc' )
+    document.save(prettify: 'abc')
   end
 
   it "should raise an error when trying to save without a filename" do
     document = SpreadBase::Document.new
-    document.tables << SpreadBase::Table.new( 'Ya-ha!' )
+    document.tables << SpreadBase::Table.new('Ya-ha!')
 
-    lambda { document.save }.should raise_error( RuntimeError, "Document path not specified" )
+    expect { document.save }.to raise_error(RuntimeError, "Document path not specified")
   end
 
   it "should raise an error when trying to save without tables" do
     document = SpreadBase::Document.new
     document.document_path = 'abc.ods'
 
-    lambda { document.save }.should raise_error( RuntimeError, "At least one table must be present" )
+    expect { document.save }.to raise_error(RuntimeError, "At least one table must be present")
   end
 
   it "should return the data as string (:to_s)" do
@@ -105,14 +83,14 @@ describe SpreadBase::Document do
 abc:
 
   +------------+---------------------------+---------------------------+
-  | 1          | 1.1                       | 0.133E1                   |
-  | 2012-04-10 | 2012-04-11T23:33:42+00:00 | 2012-04-11 23:33:42 +0200 |
-  | true       | a                         |                           |
+  | 1          | 1.1                       | 1.33                      |
+  | 2012-04-10 | 2012-04-11 23:33:42 +0000 | 2012-04-11 23:33:42 +0200 |
+  | true       | a                         | NIL                       |
   +------------+---------------------------+---------------------------+
 
 "
 
-    @sample_document.to_s.should == expected_string
+    expect(@sample_document.to_s).to eq(expected_string)
   end
 
   it "should return the data as string, with headers (:to_s)" do
@@ -120,15 +98,38 @@ abc:
 abc:
 
   +------------+---------------------------+---------------------------+
-  | 1          | 1.1                       | 0.133E1                   |
+  | 1          | 1.1                       | 1.33                      |
   +------------+---------------------------+---------------------------+
-  | 2012-04-10 | 2012-04-11T23:33:42+00:00 | 2012-04-11 23:33:42 +0200 |
-  | true       | a                         |                           |
+  | 2012-04-10 | 2012-04-11 23:33:42 +0000 | 2012-04-11 23:33:42 +0200 |
+  | true       | a                         | NIL                       |
   +------------+---------------------------+---------------------------+
 
 "
 
-    @sample_document.to_s( :with_headers => true ).should == expected_string
+    expect(@sample_document.to_s(with_headers: true)).to eq(expected_string)
+  end
+
+  it "should parse a existing ODS file" do
+    ods_file = File.expand_path('../fixtures/test.ods', __dir__)
+    document = SpreadBase::Document.new(ods_file)
+
+    expect(document.tables[0].name).to eq('Sheet1')
+    expect(document.tables[0].data).to match([
+      match(['hoge'                                      ]),
+      match([nil   , 'fuga'                              ]),
+      match([nil   , nil   , 'piyo'                      ]),
+      match([nil   , nil   , nil   , 'hogera'            ]),
+      match([nil   , nil   , nil   , nil     , 'hogehoge'])
+    ])
+
+    expect(document.tables[1].name).to eq('Sheet2')
+    expect(document.tables[1].data).to match([
+      match([nil  , nil     , nil  , nil  , 'foo']),
+      match([nil  , nil     , nil  , 'bar'       ]),
+      match([nil  , nil     , 'baz'              ]),
+      match([nil  , 'foobar'                     ]),
+      match(['qux'                               ])
+    ])
   end
 
 end

data/spec/elements/table_spec.rb

@@ -1,36 +1,18 @@
- # encoding: UTF-8
-
-=begin
-Copyright 2012 Saverio Miroddi saverio.pub2 <a-hat!> gmail.com
-
-This file is part of SpreadBase.
-
-SpreadBase is free software: you can redistribute it and/or modify it under the
-terms of the GNU Lesser General Public License as published by the Free Software
-Foundation, either version 3 of the License, or (at your option) any later
-version.
-
-SpreadBase is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public License along
-with SpreadBase.  If not, see <http://www.gnu.org/licenses/>.
-=end
-
-require File.expand_path( '../../../lib/spreadbase', __FILE__ )
-require File.expand_path( '../../spec_helpers',      __FILE__ )
+require_relative '../../lib/spreadbase'
+require_relative '../spec_helpers'
 
 include SpecHelpers
 
+include SpreadBase
+
 describe SpreadBase::Table do
 
   before :each do
     @sample_table = SpreadBase::Table.new(
       'abc', [
-        [ 1,      1.1,        T_BIGDECIMAL ],
-        [ T_DATE, T_DATETIME, T_TIME       ],
-        [ true,   'a',        nil          ]
+        [1,      1.1,             T_BIGDECIMAL],
+        [T_DATE, T_DATETIME,      T_TIME],
+        [true,   Cell.new('a'), nil]
       ]
     )
   end
@@ -39,89 +21,133 @@ describe SpreadBase::Table do
   # this routine is called, by checking against the index (-1).
   #
   it "should check the row index" do
-    lambda { @sample_table.row( 4 ) }.should raise_error( RuntimeError, "Invalid row index (4) - allowed 0 to 2" )
+    expect { @sample_table.row(4) }.to raise_error(RuntimeError, "Invalid row index (4) - allowed 0 to 2")
 
     # called with :allow_append
-    lambda { @sample_table.insert_row( -1, [] ) }.should raise_error( RuntimeError, "Invalid row index (-1) - allowed 0 to 3" )
-    lambda { @sample_table.insert_row( 40, [] ) }.should raise_error( RuntimeError, "Invalid row index (40) - allowed 0 to 3" )
+    expect { @sample_table.insert_row(-1, []) }.to raise_error(RuntimeError, "Invalid row index (-1) - allowed 0 to 3")
+    expect { @sample_table.insert_row(40, []) }.to raise_error(RuntimeError, "Invalid row index (40) - allowed 0 to 3")
   end
 
-  it "should initialize with data" do
+  it "should initialize with data, and return the data" do
     expected_data = [
-      [ 1,      1.1,        T_BIGDECIMAL ],
-      [ T_DATE, T_DATETIME, T_TIME       ],
-      [ true,   'a',        nil          ]
+      [1,      1.1,        T_BIGDECIMAL],
+      [T_DATE, T_DATETIME, T_TIME],
+      [true,   'a',        nil]
     ]
 
-    @sample_table.data.should == expected_data
+    expect(@sample_table.data).to eq(expected_data)
+  end
+
+  it "return the data in cell format" do
+    expected_data = [
+      [Cell.new(1),      Cell.new(1.1),        Cell.new(T_BIGDECIMAL)],
+      [Cell.new(T_DATE), Cell.new(T_DATETIME), Cell.new(T_TIME)],
+      [Cell.new(true),   Cell.new('a'),        Cell.new(nil)]
+    ]
+
+    expect(@sample_table.data(as_cell: true)).to eq(expected_data)
   end
 
   it "should raise an error when the initialization requirements are not met" do
-    lambda { SpreadBase::Table.new( nil ) }.should raise_error( "Table name required" )
-    lambda { SpreadBase::Table.new( ''  ) }.should raise_error( "Table name required" )
+    expect { SpreadBase::Table.new(nil) }.to raise_error("Table name required")
+    expect { SpreadBase::Table.new('') }.to raise_error("Table name required")
 
     # This is acceptable
     #
-    SpreadBase::Table.new( ' ' )
+    SpreadBase::Table.new(' ')
   end
 
   it "should access a cell" do
-    @sample_table[ 'a', 0 ].should == 1
-    @sample_table[ 1,   0 ].should == 1.1
-    @sample_table[ 2,   0 ].should == T_BIGDECIMAL
-    @sample_table[ 0,   1 ].should == T_DATE
-    @sample_table[ 'B', 1 ].should == T_DATETIME
-    @sample_table[ 2,   1 ].should == T_TIME
-    @sample_table[ 0,   2 ].should == true
-    @sample_table[ 1,   2 ].should == 'a'
-    @sample_table[ 2,   2 ].should == nil
-
-    lambda { @sample_table[ -1, 0 ] }.should raise_error( RuntimeError, "Negative column indexes not allowed: -1" )
-    lambda { @sample_table[ 0, -1 ] }.should raise_error( RuntimeError, "Invalid row index (-1) - allowed 0 to 2" )
-    lambda { @sample_table[ 3, 0  ] }.should raise_error( RuntimeError, "Invalid column index (3) for the given row - allowed 0 to 2" )
+    expect(@sample_table['a', 0]).to eq(1)
+    expect(@sample_table[1,   0]).to eq(1.1)
+    expect(@sample_table[2,   0]).to eq(T_BIGDECIMAL)
+    expect(@sample_table[0,   1]).to eq(T_DATE)
+    expect(@sample_table['B', 1]).to eq(T_DATETIME)
+    expect(@sample_table[2,   1]).to eq(T_TIME)
+    expect(@sample_table[0,   2]).to eq(true)
+    expect(@sample_table[1,   2]).to eq('a')
+    expect(@sample_table[2,   2]).to eq(nil)
+
+    expect(@sample_table[1, 2, as_cell: true]).to eq(Cell.new('a'))
+
+    expect { @sample_table[-1, 0] }.to raise_error(RuntimeError, "Negative column indexes not allowed: -1")
+    expect { @sample_table[0, -1] }.to raise_error(RuntimeError, "Invalid row index (-1) - allowed 0 to 2")
+    expect { @sample_table[3, 0] }.to raise_error(RuntimeError, "Invalid column index (3) for the given row - allowed 0 to 2")
   end
 
   it "should set a cell value" do
-    @sample_table[ 0,   0 ] = 10
-    @sample_table[ 'B', 1 ] = T_TIME
+    @sample_table[0,   0] = 10
+    @sample_table['B', 1] = Cell.new(T_TIME)
 
-    @sample_table.data.should == [
-      [ 10,     1.1,        T_BIGDECIMAL ],
-      [ T_DATE, T_TIME,     T_TIME       ],
-      [ true,   'a',        nil          ],
-    ]
+    expect(@sample_table.data).to eq([
+      [10,     1.1,        T_BIGDECIMAL],
+      [T_DATE, T_TIME,     T_TIME],
+      [true,   'a',        nil],
+    ])
 
-    lambda { @sample_table[ 0, -1 ] = 33 }.should raise_error( RuntimeError, "Invalid row index (-1) - allowed 0 to 2" )
-    lambda { @sample_table[ 3, 0  ] = 44 }.should raise_error( RuntimeError, "Invalid column index (3) for the given row - allowed 0 to 2" )
+    expect { @sample_table[0, -1] = 33 }.to raise_error(RuntimeError, "Invalid row index (-1) - allowed 0 to 2")
+    expect { @sample_table[3, 0] = 44 }.to raise_error(RuntimeError, "Invalid column index (3) for the given row - allowed 0 to 2")
   end
 
   it "should access a row" do
-    @sample_table.row( 0 ).should == [ 1,      1.1,        T_BIGDECIMAL ]
-    @sample_table.row( 1 ).should == [ T_DATE, T_DATETIME, T_TIME       ]
+    expect(@sample_table.row(0)).to eq([1, 1.1, T_BIGDECIMAL])
+
+    expect(@sample_table.row(1, as_cell: true)).to eq([Cell.new(T_DATE), Cell.new(T_DATETIME), Cell.new(T_TIME)])
+
+    expect { @sample_table.row(-1) }.to raise_error(RuntimeError, "Invalid row index (-1) - allowed 0 to 2")
+  end
 
-    lambda { @sample_table.row( -1 ) }.should raise_error( RuntimeError, "Invalid row index (-1) - allowed 0 to 2" )
+  it "should access a set of rows by range" do
+    expect(@sample_table.row(0..1)).to eq([
+      [1,      1.1,        T_BIGDECIMAL],
+      [T_DATE, T_DATETIME, T_TIME],
+    ])
+
+    expect { @sample_table.row(0..5) }.to raise_error(RuntimeError, "Invalid row index (5) - allowed 0 to 2")
+  end
+
+  it "should access a set of rows by range (as cell)" do
+    expect(@sample_table.row(0..1, as_cell: true)).to eq([
+      [Cell.new(1),      Cell.new(1.1),        Cell.new(T_BIGDECIMAL)],
+      [Cell.new(T_DATE), Cell.new(T_DATETIME), Cell.new(T_TIME)],
+    ])
+
+    expect { @sample_table.row(0..5) }.to raise_error(RuntimeError, "Invalid row index (5) - allowed 0 to 2")
   end
 
   it "should delete a row" do
-    @sample_table.delete_row( 1 ).should == [ T_DATE, T_DATETIME, T_TIME ]
+    expect(@sample_table.delete_row(1)).to eq([T_DATE, T_DATETIME, T_TIME])
 
-    @sample_table.data.should == [
-      [ 1,      1.1,        T_BIGDECIMAL ],
-      [ true,   'a',        nil          ],
-    ]
+    expect(@sample_table.data).to eq([
+      [1,      1.1,        T_BIGDECIMAL],
+      [true,   'a',        nil],
+    ])
 
-    lambda { @sample_table.delete_row( -1 ) }.should raise_error( RuntimeError, "Invalid row index (-1) - allowed 0 to 1" )
+    expect { @sample_table.delete_row(-1) }.to raise_error(RuntimeError, "Invalid row index (-1) - allowed 0 to 1")
+  end
+
+  it "should delete a set of rows by range" do
+    expect(@sample_table.delete_row(0..1)).to eq([
+      [1,      1.1,        T_BIGDECIMAL],
+      [T_DATE, T_DATETIME, T_TIME],
+    ])
+
+    expect(@sample_table.data).to eq([
+      [true,   'a',        nil]
+    ])
+
+    expect { @sample_table.delete_row(0..5) }.to raise_error(RuntimeError, "Invalid row index (5) - allowed 0 to 0")
   end
 
   it "should insert a row" do
-    @sample_table.insert_row( 1, [ 4, 5, 6 ] )
+    @sample_table.insert_row(1, [4, Cell.new(5), 6])
 
-    @sample_table.data.should == [
-      [ 1,      1.1,        T_BIGDECIMAL ],
-      [ 4,      5,          6            ],
-      [ T_DATE, T_DATETIME, T_TIME       ],
-      [ true,   'a',        nil          ],
-    ]
+    expect(@sample_table.data).to eq([
+      [1,      1.1,        T_BIGDECIMAL],
+      [4,      5,          6],
+      [T_DATE, T_DATETIME, T_TIME],
+      [true,   'a',        nil],
+    ])
 
     # illegal row index tested in separate UT
   end
@@ -129,139 +155,172 @@ describe SpreadBase::Table do
   it "should insert a row without error if there is no data" do
     @sample_table.data = []
 
-    @sample_table.insert_row( 0, [ 4, 5 ] )
+    @sample_table.insert_row(0, [4, 5])
 
-    @sample_table.data.size.should == 1
+    expect(@sample_table.data.size).to eq(1)
   end
 
   it "should append a row" do
-    @sample_table.append_row( [ 4, 5, 6 ] )
-
-    @sample_table.data.should == [
-      [ 1,      1.1,        T_BIGDECIMAL ],
-      [ T_DATE, T_DATETIME, T_TIME       ],
-      [ true,   'a',        nil          ],
-      [ 4,      5,          6            ],
-    ]
+    @sample_table.append_row([4, Cell.new(5), 6])
+
+    expect(@sample_table.data).to eq([
+      [1,      1.1,        T_BIGDECIMAL],
+      [T_DATE, T_DATETIME, T_TIME],
+      [true,   'a',        nil],
+      [4,      5,          6],
+    ])
   end
 
   it "should access a column" do
-    @sample_table.column( 0 ).should == [ 1,   T_DATE,     true ]
-    @sample_table.column( 1 ).should == [ 1.1, T_DATETIME, 'a'  ]
+    expect(@sample_table.column(0)).to eq([1,   T_DATE,     true])
+
+    expect(@sample_table.column(1, as_cell: true)).to eq([Cell.new(1.1), Cell.new(T_DATETIME), Cell.new('a')])
+
+    expect(@sample_table.column(3)).to eq([nil, nil, nil])
+  end
+
+  it "should access a set of columns by range" do
+    expect(@sample_table.column(0..1)).to eq([
+      [1,   T_DATE,     true],
+      [1.1, T_DATETIME, 'a'],
+    ])
 
-    @sample_table.column( 3 ).should == [ nil, nil, nil ]
+    expect(@sample_table.column('C'..'D')).to eq([
+      [T_BIGDECIMAL, T_TIME, nil],
+      [nil,          nil,    nil],
+    ])
+  end
+
+  it "should access a set of columns by range (as cell )" do
+    expect(@sample_table.column(0..1, as_cell: true)).to eq([
+      [Cell.new(1),   Cell.new(T_DATE),     Cell.new(true)],
+      [Cell.new(1.1), Cell.new(T_DATETIME), Cell.new('a')],
+    ])
   end
 
   it "should delete a column" do
-    @sample_table.column_width_styles = [ 'abc', nil, 'cde' ]
+    @sample_table.column_width_styles = ['abc', nil, 'cde']
 
-    @sample_table.delete_column( 0 ).should == [ 1, T_DATE, true ]
+    expect(@sample_table.delete_column(0)).to eq([1, T_DATE, true])
 
-    @sample_table.column_width_styles.should == [ nil, 'cde' ]
+    expect(@sample_table.column_width_styles).to eq([nil, 'cde'])
 
-    @sample_table.delete_column( 3 ).should == [ nil, nil, nil ]
+    expect(@sample_table.delete_column(3)).to eq([nil, nil, nil])
 
-    @sample_table.column_width_styles.should == [ nil, 'cde' ]
+    expect(@sample_table.column_width_styles).to eq([nil, 'cde'])
 
-    @sample_table.data.should == [
-      [ 1.1,        T_BIGDECIMAL ],
-      [ T_DATETIME, T_TIME       ],
-      [ 'a',        nil          ]
-    ]
+    expect(@sample_table.data).to eq([
+      [1.1,        T_BIGDECIMAL],
+      [T_DATETIME, T_TIME],
+      ['a',        nil]
+    ])
+  end
+
+  it "should delete a set of columns by range" do
+    expect(@sample_table.delete_column(0..1)).to eq([
+      [1,   T_DATE, true],
+      [1.1, T_DATETIME, 'a'],
+    ])
+
+    expect(@sample_table.data).to eq([
+      [T_BIGDECIMAL],
+      [T_TIME],
+      [nil],
+    ])
   end
 
   it "should insert a column" do
     # Setup/fill table
 
-    @sample_table.column_width_styles = [ 'abc', nil, 'cde' ]
+    @sample_table.column_width_styles = ['abc', nil, 'cde']
 
-    @sample_table.insert_column( 1, [ 34, 'abc', nil ] )
+    @sample_table.insert_column(1, [34, 'abc', Cell.new(nil)])
 
-    @sample_table.data.should == [
-      [ 1,      34,    1.1,        T_BIGDECIMAL ],
-      [ T_DATE, 'abc', T_DATETIME, T_TIME       ],
-      [ true,   nil,   'a',        nil          ],
-    ]
+    expect(@sample_table.data).to eq([
+      [1,      34,    1.1,        T_BIGDECIMAL],
+      [T_DATE, 'abc', T_DATETIME, T_TIME],
+      [true,   nil,   'a',        nil],
+    ])
 
-    @sample_table.column_width_styles = [ 'abc', nil, nil, 'cde' ]
+    @sample_table.column_width_styles = ['abc', nil, nil, 'cde']
 
     # Empty table
 
-    table = SpreadBase::Table.new( 'abc' )
+    table = SpreadBase::Table.new('abc')
 
-    table.insert_column( 0, [ 34, 'abc', 1 ] )
+    table.insert_column(0, [34, 'abc', 1])
 
-    table.data.should == [
-      [ 34,   ],
-      [ 'abc' ],
-      [ 1     ],
-    ]
+    expect(table.data).to eq([
+      [34,],
+      ['abc'],
+      [1],
+    ])
 
-    @sample_table.column_width_styles = [ nil ]
+    @sample_table.column_width_styles = [nil]
   end
 
   it "should not insert a column if the size is not correct" do
-    lambda { @sample_table.insert_column( 1, [ 34, 'abc' ] ) }.should raise_error( RuntimeError, "Inserting column size (2) different than existing columns size (3)" )
+    expect { @sample_table.insert_column(1, [34, 'abc']) }.to raise_error(RuntimeError, "Inserting column size (2) different than existing columns size (3)")
 
-    @sample_table.data.first.size.should == 3
+    expect(@sample_table.data.first.size).to eq(3)
   end
 
   it "should insert a column outside the row boundaries" do
-    @sample_table.insert_column( 5, [ 34, 'abc', nil ] )
+    @sample_table.insert_column(5, [34, 'abc', nil])
 
-    @sample_table.data.should == [
-      [ 1,      1.1,        T_BIGDECIMAL, nil, nil, 34    ],
-      [ T_DATE, T_DATETIME, T_TIME,       nil, nil, 'abc' ],
-      [ true,   'a',        nil,          nil, nil, nil   ],
-    ]
+    expect(@sample_table.data).to eq([
+      [1,      1.1,        T_BIGDECIMAL, nil, nil, 34],
+      [T_DATE, T_DATETIME, T_TIME,       nil, nil, 'abc'],
+      [true,   'a',        nil,          nil, nil, nil],
+    ])
   end
 
   it "should append a column" do
-    table = SpreadBase::Table.new( 'abc' )
+    table = SpreadBase::Table.new('abc')
 
-    table.append_column( [ 34, 'abc', 1 ] )
+    table.append_column([Cell.new(34), 'abc', 1])
 
-    table.data.should == [
-      [ 34,   ],
-      [ 'abc' ],
-      [ 1     ],
-    ]
+    expect(table.data).to eq([
+      [34,],
+      ['abc'],
+      [1],
+    ])
 
-    table.append_column( [ 'cute', 'little', 'spielerin' ] )
+    table.append_column(['cute', 'little', 'spielerin'])
 
-    table.data.should == [
-      [ 34,    'cute'      ],
-      [ 'abc', 'little'    ],
-      [ 1,     'spielerin' ],
-    ]
+    expect(table.data).to eq([
+      [34,    'cute'],
+      ['abc', 'little'],
+      [1,     'spielerin'],
+    ])
   end
 
   it "return the data as string (:to_s)" do
     expected_string = "\
 +------------+---------------------------+---------------------------+
-| 1          | 1.1                       | 0.133E1                   |
-| 2012-04-10 | 2012-04-11T23:33:42+00:00 | 2012-04-11 23:33:42 +0200 |
-| true       | a                         |                           |
+| 1          | 1.1                       | 1.33                      |
+| 2012-04-10 | 2012-04-11 23:33:42 +0000 | 2012-04-11 23:33:42 +0200 |
+| true       | a                         | NIL                       |
 +------------+---------------------------+---------------------------+
 "
-    @sample_table.to_s.should == expected_string
+    expect(@sample_table.to_s).to eq(expected_string)
   end
 
   it "return the data as string, with headers (:to_s)" do
     expected_string = "\
 +------------+---------------------------+---------------------------+
-| 1          | 1.1                       | 0.133E1                   |
+| 1          | 1.1                       | 1.33                      |
 +------------+---------------------------+---------------------------+
-| 2012-04-10 | 2012-04-11T23:33:42+00:00 | 2012-04-11 23:33:42 +0200 |
-| true       | a                         |                           |
+| 2012-04-10 | 2012-04-11 23:33:42 +0000 | 2012-04-11 23:33:42 +0200 |
+| true       | a                         | NIL                       |
 +------------+---------------------------+---------------------------+
 "
 
-    @sample_table.to_s( :with_headers => true ).should == expected_string
+    expect(@sample_table.to_s(with_headers: true)).to eq(expected_string)
 
     @sample_table.data = []
 
-    @sample_table.to_s( :with_headers => true ).should == ""
+    expect(@sample_table.to_s(with_headers: true)).to eq("")
   end
 
 end