spreadbase 0.1.3 → 0.1.4

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,111 +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])
 
-    lambda { @sample_table.row( -1 ) }.should raise_error( RuntimeError, "Invalid row index (-1) - allowed 0 to 2" )
+    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
 
   it "should access a set of rows by range" do
-    @sample_table.row( ( 0 .. 1 ) ).should == [
-      [ 1,      1.1,        T_BIGDECIMAL ],
-      [ T_DATE, T_DATETIME, T_TIME       ],
-    ]
+    expect(@sample_table.row(0..1)).to eq([
+      [1,      1.1,        T_BIGDECIMAL],
+      [T_DATE, T_DATETIME, T_TIME],
+    ])
 
-    lambda { @sample_table.row( ( 0 .. 5 ) ) }.should raise_error( RuntimeError, "Invalid row index (5) - allowed 0 to 2" )
+    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
-    @sample_table.delete_row( ( 0 .. 1 ) ).should == [
-      [ 1,      1.1,        T_BIGDECIMAL ],
-      [ T_DATE, T_DATETIME, T_TIME       ],
-    ]
+    expect(@sample_table.delete_row(0..1)).to eq([
+      [1,      1.1,        T_BIGDECIMAL],
+      [T_DATE, T_DATETIME, T_TIME],
+    ])
 
-    @sample_table.data.should == [
-      [ true,   'a',        nil          ]
-    ]
+    expect(@sample_table.data).to eq([
+      [true,   'a',        nil]
+    ])
 
-    lambda { @sample_table.delete_row( ( 0 .. 5 ) ) }.should raise_error( RuntimeError, "Invalid row index (5) - allowed 0 to 0" )
+    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
@@ -151,164 +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])
 
-    @sample_table.column( 3 ).should == [ nil, nil, nil ]
+    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
-    @sample_table.column( ( 0 .. 1 ) ).should == [
-      [ 1,   T_DATE,     true ],
-      [ 1.1, T_DATETIME, 'a'  ],
-    ]
+    expect(@sample_table.column(0..1)).to eq([
+      [1,   T_DATE,     true],
+      [1.1, T_DATETIME, 'a'],
+    ])
+
+    expect(@sample_table.column('C'..'D')).to eq([
+      [T_BIGDECIMAL, T_TIME, nil],
+      [nil,          nil,    nil],
+    ])
+  end
 
-    @sample_table.column( ( 'C' .. 'D' ) ).should == [
-      [ T_BIGDECIMAL, T_TIME, nil ],
-      [ nil,          nil,    nil ],
-    ]
+  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
-    @sample_table.delete_column( ( 0 .. 1 ) ).should == [
-      [ 1,   T_DATE, true ],
-      [ 1.1, T_DATETIME, 'a'  ],
-    ]
-
-    @sample_table.data.should == [
-      [ T_BIGDECIMAL ],
-      [ T_TIME       ],
-      [ nil          ],
-    ]
+    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

data/spec/spec_helper.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+#  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+#  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = "doc"
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+#  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+end

data/spec/spec_helpers.rb

@@ -1,45 +1,25 @@
-# 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 'date'
 require 'bigdecimal'
 
 module SpecHelpers
 
-  T_DATE       = Date.new( 2012, 4, 10 )
-  T_DATETIME   = DateTime.new( 2012, 4, 11, 23, 33, 42 )
-  T_TIME       = Time.local( 2012, 4, 11, 23, 33, 42 )
-  T_BIGDECIMAL = BigDecimal.new( '1.33' )
+  T_DATE       = Date.new(2012, 4, 10)
+  T_DATETIME   = DateTime.new(2012, 4, 11, 23, 33, 42)
+  T_TIME       = Time.new(2012, 4, 11, 23, 33, 42, "+02:00")
+  T_BIGDECIMAL = BigDecimal('1.33')
 
   # This method is cool beyond any argument about the imperfect name.
   #
-  def assert_size( collection, expected_size )
-    collection.size.should == expected_size
+  def assert_size(collection, expected_size)
+    expect(collection.size).to eql(expected_size)
 
-    yield( *collection ) if block_given?
+    yield(*collection) if block_given?
   end
 
-  def stub_initializer( klazz, *args )
-    instance = klazz.new( *args )
+  def stub_initializer(klazz, *args)
+    instance = klazz.new(*args)
 
-    klazz.stub!( :new ).and_return( instance )
+    allow(klazz).to receive(:new) { instance }
 
     instance
   end