edtf 2.1.0 → 2.2.0

data/spec/edtf/epoch_spec.rb

@@ -4,56 +4,56 @@ module EDTF
 	
 	describe Decade do
 		
-		it { should_not be nil }
+		it { is_expected.not_to be nil }
 
 		describe '.current' do
 			it 'creates the current decade' do
-				Decade.current.year.should == (Time.now.year / 10) * 10
+				expect(Decade.current.year).to eq((Time.now.year / 10) * 10)
 			end
 		end
 		
 		describe '#min' do
 			it 'the year 1990 should be the minimum of the 1990s' do
-				Decade.new(1999).min.should == Date.new(1990).year_precision!
+				expect(Decade.new(1999).min).to eq(Date.new(1990).year_precision!)
 			end
 		end
 
 		describe '#max' do
 			it 'the year 1999 should be the maximum of the 1990s' do
-				Decade.new(1999).max.should == Date.new(1999).year_precision!
+				expect(Decade.new(1999).max).to eq(Date.new(1999).year_precision!)
 			end
 			
 			it 'has year precision' do
-				Decade.new(1999).max.should be_year_precision
+				expect(Decade.new(1999).max).to be_year_precision
 			end
 		end
 
 		describe '#cover?' do
 			it '1989-12-31 should be covered by the 1980s' do
-				Decade.new(1980).should be_cover(Date.new(1989,12,31))
+				expect(Decade.new(1980)).to be_cover(Date.new(1989,12,31))
 			end
 		end
 		
 		describe '#to_range' do
 			
 			it 'returns a range' do
-				Decade.new.to_range.should be_instance_of(::Range)
+				expect(Decade.new.to_range).to be_instance_of(::Range)
 			end
 			
 			it 'the range starts with a date object' do
-				Decade.new.to_range.begin.should be_instance_of(::Date)
+				expect(Decade.new.to_range.begin).to be_instance_of(::Date)
 			end
 
 			it 'the range ends with a date object' do
-				Decade.new.to_range.end.should be_instance_of(::Date)
+				expect(Decade.new.to_range.end).to be_instance_of(::Date)
 			end
 
 			it 'the range start has year precision' do
-				Decade.new.to_range.begin.should be_year_precision
+				expect(Decade.new.to_range.begin).to be_year_precision
 			end
 
 			it 'the range end has year precision' do
-				Decade.new.to_range.end.should be_year_precision
+				expect(Decade.new.to_range.end).to be_year_precision
 			end
 			
 		end
@@ -61,11 +61,11 @@ module EDTF
 		describe 'enumeration' do
 			
 			it 'always covers ten years' do
-				Decade.new.to_a.should have(10).elements
+				expect(Decade.new.to_a.size).to eq(10)
 			end
 			
 			it 'the 1970s should map to the years [1970, 1971, ... , 1979]' do
-				Decade.new(1970).map(&:year).should == [1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979]
+				expect(Decade.new(1970).map(&:year)).to eq([1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979])
 			end
 		
 		end
@@ -74,11 +74,11 @@ module EDTF
 
 	describe Century do
 		
-		it { should_not be nil }
+		it { is_expected.not_to be nil }
 
 		describe '.current' do
 			it 'creates the current century' do
-				Century.current.year.should == (Time.now.year / 100) * 100
+				expect(Century.current.year).to eq((Time.now.year / 100) * 100)
 			end
 		end
 		

data/spec/edtf/interval_spec.rb

@@ -4,58 +4,58 @@ module EDTF
     describe 'the interval 2008/2011' do
       let(:interval) { Date.edtf('2008/2011') }
 
-			it { interval.should_not be_open }
-			it { interval.should_not be_open_end }
-			it { interval.should_not be_unknown_start }
-			it { interval.should_not be_unknown_end }
+			it { expect(interval).not_to be_open }
+			it { expect(interval).not_to be_open_end }
+			it { expect(interval).not_to be_unknown_start }
+			it { expect(interval).not_to be_unknown_end }
 
       it 'has a length of 4' do
-        interval.to_a.length.should == 4
+        expect(interval.to_a.length).to eq(4)
       end
 
       it '#step(2) yields the years 2008 and 2010' do
-        interval.step(2).map(&:year).should == [2008,2010]
+        expect(interval.step(2).map(&:year)).to eq([2008,2010])
       end
 
       it 'the max date is 2011-12-31' do
-        interval.max.to_s.should == '2011-12-31'
+        expect(interval.max.to_s).to eq('2011-12-31')
       end
 
       it 'the max date has year precision' do
-        interval.max.should be_year_precision
+        expect(interval.max).to be_year_precision
       end
 
       it 'the min date is 2008-01-01' do
-        interval.min.to_s.should == '2008-01-01'
+        expect(interval.min.to_s).to eq('2008-01-01')
       end
 
       it 'the min date has year precision' do
-        interval.min.should be_year_precision
+        expect(interval.min).to be_year_precision
       end
 
 
       it 'includes the years 2008, 2009, 2010 and 2011' do
-        interval.to_a.map(&:year).should == [2008, 2009, 2010, 2011]
+        expect(interval.to_a.map(&:year)).to eq([2008, 2009, 2010, 2011])
       end
 
       it 'does not include christmas day 2009' do
-        interval.should_not be_include(Date.new(2009,12,24))
+        expect(interval).not_to be_include(Date.new(2009,12,24))
       end
 
       it 'christmas day 2009 is less than max' do
-        Date.new(2009,12,24).should < interval.max
+        expect(Date.new(2009,12,24)).to be < interval.max
       end
 
       it 'christmas day 2009 is greater than min' do
-        Date.new(2009,12,24).should > interval.min
+        expect(Date.new(2009,12,24)).to be > interval.min
       end
 
       it 'covers christmas day 2009' do
-        interval.should be_cover(Date.new(2009,12,24))
+        expect(interval).to be_cover(Date.new(2009,12,24))
       end
 
       it 'covers 2011-12-31' do
-        interval.should be_cover(Date.new(2011,12,31))
+        expect(interval).to be_cover(Date.new(2011,12,31))
       end
     end
 
@@ -63,72 +63,72 @@ module EDTF
       let(:interval) { Date.edtf('2008-08-23/2011-07-01') }
 
       it 'includes christmas day 2009' do
-        interval.should be_include(Date.new(2009,12,24))
+        expect(interval).to be_include(Date.new(2009,12,24))
       end
 
       it 'covers christmas day 2009' do
-        interval.should be_cover(Date.new(2009,12,24))
+        expect(interval).to be_cover(Date.new(2009,12,24))
       end
 
       it 'does not cover 2011-07-02' do
-        interval.should_not be_cover(Date.new(2011,07,02))
+        expect(interval).not_to be_cover(Date.new(2011,07,02))
       end
     end
 
     describe 'the interval 2008-08-23/open' do
       let(:interval) { Date.edtf('2008-08-23/open') }
 
-      it { interval.should be_open }
-      it { interval.should be_open_end }
-      it { interval.should_not be_unknown }
-      it { interval.should_not be_unknown_start }
-      it { interval.should_not be_unknown_end }
+      it { expect(interval).to be_open }
+      it { expect(interval).to be_open_end }
+      it { expect(interval).not_to be_unknown }
+      it { expect(interval).not_to be_unknown_start }
+      it { expect(interval).not_to be_unknown_end }
 
       it 'the min date is 2008-08-23' do
-        interval.min.should == Date.new(2008,8,23)
+        expect(interval.min).to eq(Date.new(2008,8,23))
       end
 
       it 'the max date is nil' do
-        interval.max.should be nil
+        expect(interval.max).to be nil
       end
 
       it 'includes christmas day 2009' do
-        interval.should be_include(Date.new(2009,12,24))
+        expect(interval).to be_include(Date.new(2009,12,24))
       end
 
       it 'covers christmas day 2009' do
-        interval.should be_cover(Date.new(2009,12,24))
+        expect(interval).to be_cover(Date.new(2009,12,24))
       end
 
       it 'covers 2023-07-02' do
-        interval.should be_cover(Date.new(2023,07,02))
+        expect(interval).to be_cover(Date.new(2023,07,02))
       end
 
     end
 
     describe 'comparisions' do
       it '2007/2009 should be greater than 2001/2002' do
-        Date.edtf('2007/2009').should > Date.edtf('2001/2002')
+        expect(Date.edtf('2007/2009')).to be > Date.edtf('2001/2002')
       end
 
       it '2007/2009 should be less than 2011/2012' do
-        Date.edtf('2007/2009').should < Date.edtf('2011/2012')
+        expect(Date.edtf('2007/2009')).to be < Date.edtf('2011/2012')
       end
 
       it '2007/2009 should be less than 2008/2009' do
-        Date.edtf('2007/2009').should < Date.edtf('2008/2009')
+        expect(Date.edtf('2007/2009')).to be < Date.edtf('2008/2009')
       end
 
       it '2007/2009 should be greater than 2007/2008' do
-        Date.edtf('2007/2009').should > Date.edtf('2007/2008')
+        expect(Date.edtf('2007/2009')).to be > Date.edtf('2007/2008')
       end
 
       it '2007/2009 should be greater than 2006/2007' do
-        Date.edtf('2007/2009').should > Date.edtf('2006/2007')
+        expect(Date.edtf('2007/2009')).to be > Date.edtf('2006/2007')
       end
 
       it '2007/2009 should be equal to 2007/2009' do
-        Date.edtf('2007/2009').should == Date.edtf('2007/2009')
+        expect(Date.edtf('2007/2009')).to eq(Date.edtf('2007/2009'))
       end
     end
 

data/spec/edtf/parser_spec.rb

@@ -3,349 +3,349 @@ module EDTF
     describe '#parse' do
       
       it 'parses simple dates "2001-02-03"' do
-        Parser.new.parse('2001-02-03').to_s.should == '2001-02-03'
+        expect(Parser.new.parse('2001-02-03').to_s).to eq('2001-02-03')
       end
       
       it 'parses negative years' do
-        Parser.new.parse('-2323').to_s.should == '-2323-01-01'
+        expect(Parser.new.parse('-2323').to_s).to eq('-2323-01-01')
       end
       
 			it 'parses the negative year -2101 and sets the precision to :year' do
-				Parser.new.parse('-2101').should be_year_precision
+				expect(Parser.new.parse('-2101')).to be_year_precision
 			end
 			
       it 'parses year zero' do
-        Parser.new.parse('0000').to_s.should == '0000-01-01'
+        expect(Parser.new.parse('0000').to_s).to eq('0000-01-01')
       end
       
       it 'parses date/time with time zones' do
-        Parser.new.parse('2011-08-15T11:19:00+01:00').to_s.should == '2011-08-15T11:19:00+01:00'
+        expect(Parser.new.parse('2011-08-15T11:19:00+01:00').to_s).to eq('2011-08-15T11:19:00+01:00')
       end
       
       it 'parses simple intervals like "2007/2008"' do
-        Parser.new.parse('2007/2008').should be_a(Interval)
+        expect(Parser.new.parse('2007/2008')).to be_a(Interval)
       end
    
       it 'parses uncertain dates' do
-        Parser.new.parse('1984?').should be_uncertain        
-        Parser.new.parse('1984').should be_certain
+        expect(Parser.new.parse('1984?')).to be_uncertain        
+        expect(Parser.new.parse('1984')).to be_certain
       end
 
       it 'parses uncertain dates (day precision)' do
-        Parser.new.parse('1984-11-23?').should be_uncertain        
-        Parser.new.parse('1984-11-23').should be_certain
+        expect(Parser.new.parse('1984-11-23?')).to be_uncertain        
+        expect(Parser.new.parse('1984-11-23')).to be_certain
       end
 
       it 'parses approximate dates' do
-        Parser.new.parse('1984-01~').should be_approximate
-        Parser.new.parse('1984-01').should be_precise
+        expect(Parser.new.parse('1984-01~')).to be_approximate
+        expect(Parser.new.parse('1984-01')).to be_precise
       end
 
       it 'parses uncertain approximate dates' do
-        Parser.new.parse('1984?~').should be_uncertain
-        Parser.new.parse('1984?~').should be_approximate
+        expect(Parser.new.parse('1984?~')).to be_uncertain
+        expect(Parser.new.parse('1984?~')).to be_approximate
       end
 
       it 'parses unspecified dates' do
-        Parser.new.parse('199u').should be_unspecified
-        Parser.new.parse('1999-uu-uu').should be_unspecified
+        expect(Parser.new.parse('199u')).to be_unspecified
+        expect(Parser.new.parse('1999-uu-uu')).to be_unspecified
       end
       
       it 'parses open intervals' do
-        Parser.new.parse('2004-01-01/open').should be_open
+        expect(Parser.new.parse('2004-01-01/open')).to be_open
       end
 
       it 'parses unknown intervals' do
-        Parser.new.parse('2004-01-01/unknown').should be_unknown_end
-        Parser.new.parse('unknown/2004-01-01').should be_unknown_start
+        expect(Parser.new.parse('2004-01-01/unknown')).to be_unknown_end
+        expect(Parser.new.parse('unknown/2004-01-01')).to be_unknown_start
       end
       
       it 'parses intervals with uncertain or approximate dates' do
-        Parser.new.parse('1984-06-02?/2004-08-08~').from.should be_uncertain
-        Parser.new.parse('1984-06-02?/2004-08-08~').to.should be_approximate
+        expect(Parser.new.parse('1984-06-02?/2004-08-08~').from).to be_uncertain
+        expect(Parser.new.parse('1984-06-02?/2004-08-08~').to).to be_approximate
       end
       
       it 'parses positive long years' do
-        Parser.new.parse('y170000002').year.should == 170000002
+        expect(Parser.new.parse('y170000002').year).to eq(170000002)
       end
       
       it 'parses negative long years' do
-        Parser.new.parse('y-170000002').year.should == -170000002
+        expect(Parser.new.parse('y-170000002').year).to eq(-170000002)
       end
       
       it 'parses season codes' do
-        Parser.new.parse('2003-23').should be_autumn
+        expect(Parser.new.parse('2003-23')).to be_autumn
       end
 
       it 'parses calendar names' do
-        Parser.new.parse('2001-02-03^xyz').calendar.should == 'xyz'
+        expect(Parser.new.parse('2001-02-03^xyz').calendar).to eq('xyz')
       end
       
       it 'parses season qualifiers' do
         d = Parser.new.parse('2003-23^european')
-        d.should be_autumn
-        d.should be_qualified
-        d.qualifier.should == 'european'
+        expect(d).to be_autumn
+        expect(d).to be_qualified
+        expect(d.qualifier).to eq('european')
       end
       
 			it 'parses uncertain seasons' do
-        Parser.new.parse!('2003-23?').should be_uncertain
+        expect(Parser.new.parse!('2003-23?')).to be_uncertain
 			end
 
 			it 'parses approximate seasons' do
-        Parser.new.parse!('2003-23~').should be_approximate
+        expect(Parser.new.parse!('2003-23~')).to be_approximate
 			end
 
 			it 'parses uncertain and approximate seasons' do
-        Parser.new.parse!('2003-23?~').should be_uncertain
-        Parser.new.parse!('2003-23?~').should be_approximate
+        expect(Parser.new.parse!('2003-23?~')).to be_uncertain
+        expect(Parser.new.parse!('2003-23?~')).to be_approximate
 			end
 			
 			
       it 'parses positive scientific long years' do
-        Parser.new.parse('y17e7').year.should == 170000000
+        expect(Parser.new.parse('y17e7').year).to eq(170000000)
       end
       
       it 'parses negative scientific long years' do
-        Parser.new.parse('y-17e7').year.should == -170000000        
+        expect(Parser.new.parse('y-17e7').year).to eq(-170000000)        
       end
       
       it 'parses masked precision date strings (decades)' do
         d = Parser.new.parse!('198x')
-        d.should be_cover(Date.new(1983,3,12))
-        d.should_not be_cover(Date.new(1990,1,1))
+        expect(d).to be_cover(Date.new(1983,3,12))
+        expect(d).not_to be_cover(Date.new(1990,1,1))
       end
 
       it 'parses masked precision date strings (centuries)' do
         d = Parser.new.parse!('18xx')
-        d.should be_cover(Date.new(1848,1,14))
-        d.should_not be_cover(Date.new(1799,12,31))
+        expect(d).to be_cover(Date.new(1848,1,14))
+        expect(d).not_to be_cover(Date.new(1799,12,31))
       end
       
       it 'parses multiple dates (years)' do
         d = Parser.new.parse!('{1667,1668, 1670..1672}')
-        d.map(&:year).should == [1667,1668,1670,1671,1672]
+        expect(d.map(&:year)).to eq([1667,1668,1670,1671,1672])
       end
       
       it 'parses multiple dates (mixed years and months)' do
         d = Parser.new.parse!('{1960, 1961-12}')
-        d.map { |x| [x.year,x.month] }.should == [[1960,1],[1961,12]]
+        expect(d.map { |x| [x.year,x.month] }).to eq([[1960,1],[1961,12]])
       end
       
       it 'parses choice lists (One of the years 1667, 1668, 1670, 1671, 1672)' do
         d = Parser.new.parse!('[1667,1668, 1670..1672]')
-        d.map(&:year).should == [1667,1668,1670,1671,1672]
+        expect(d.map(&:year)).to eq([1667,1668,1670,1671,1672])
       end
 
       it 'parses choice lists (December 3, 1760 or some earlier date)' do
         d = Parser.new.parse!('[..1760-12-03]')
-        d.map(&:to_s).should == ['1760-12-03']
+        expect(d.map(&:to_s)).to eq(['1760-12-03'])
       end
 
       it 'parses choice lists (December 1760 or some later month)' do
         d = Parser.new.parse!('[1760-12..]')
-        d.map { |x| [x.year,x.month] }.should == [[1760,12]]
+        expect(d.map { |x| [x.year,x.month] }).to eq([[1760,12]])
       end
 
       it 'parses choice lists (January or February of 1760 or December 1760 or some later month)' do
         d = Parser.new.parse!('[1760-01, 1760-02, 1760-12..]')
-        d.length.should == 3
+        expect(d.length).to eq(3)
       end
       
       it 'parses intern unspecified "199u-01-01"' do
-        Parser.new.parse!('199u-01-01').unspecified.to_s.should == 'sssu-ss-ss'
+        expect(Parser.new.parse!('199u-01-01').unspecified.to_s).to eq('sssu-ss-ss')
       end
       
       it 'parses intern unspecified "19uu-01-01"' do
-        Parser.new.parse!('19uu-01-01').unspecified.to_s.should == 'ssuu-ss-ss'
+        expect(Parser.new.parse!('19uu-01-01').unspecified.to_s).to eq('ssuu-ss-ss')
       end
 
       it 'parses intern unspecified "199u-uu-01"' do
-        Parser.new.parse!('199u-uu-01').unspecified.to_s.should == 'sssu-uu-ss'
+        expect(Parser.new.parse!('199u-uu-01').unspecified.to_s).to eq('sssu-uu-ss')
       end
       
       it 'parses intern unspecified "19uu-uu-01"' do
-        Parser.new.parse!('19uu-uu-01').unspecified.to_s.should == 'ssuu-uu-ss'
+        expect(Parser.new.parse!('19uu-uu-01').unspecified.to_s).to eq('ssuu-uu-ss')
       end
 
       it 'parses intern unspecified "199u-uu-uu"' do
-        Parser.new.parse!('199u-uu-uu').unspecified.to_s.should == 'sssu-uu-uu'
+        expect(Parser.new.parse!('199u-uu-uu').unspecified.to_s).to eq('sssu-uu-uu')
       end
       
       it 'parses intern unspecified "19uu-uu-uu"' do
-        Parser.new.parse!('19uu-uu-uu').unspecified.to_s.should == 'ssuu-uu-uu'
+        expect(Parser.new.parse!('19uu-uu-uu').unspecified.to_s).to eq('ssuu-uu-uu')
       end
 
       it 'parses intern unspecified "199u-01-uu"' do
-        Parser.new.parse!('199u-01-uu').unspecified.to_s.should == 'sssu-ss-uu'
+        expect(Parser.new.parse!('199u-01-uu').unspecified.to_s).to eq('sssu-ss-uu')
       end
       
       it 'parses intern unspecified "19uu-01-uu"' do
-        Parser.new.parse!('19uu-01-uu').unspecified.to_s.should == 'ssuu-ss-uu'
+        expect(Parser.new.parse!('19uu-01-uu').unspecified.to_s).to eq('ssuu-ss-uu')
       end
 
       it 'parses intern unspecified "1999-uu-01"' do
-        Parser.new.parse!('1999-uu-01').unspecified.to_s.should == 'ssss-uu-ss'
+        expect(Parser.new.parse!('1999-uu-01').unspecified.to_s).to eq('ssss-uu-ss')
       end
 
       it 'parses intern unspecified "2004-06-uu"' do
-        Parser.new.parse!('2004-06-uu').unspecified.to_s.should == 'ssss-ss-uu'
+        expect(Parser.new.parse!('2004-06-uu').unspecified.to_s).to eq('ssss-ss-uu')
       end
 
       
 			it 'parses internal unspecified interval  "2004-06-uu/2004-07-03"' do
-				Parser.new.parse!('2004-06-uu/2004-07-03').from.should == Date.new(2004,6,1)
+				expect(Parser.new.parse!('2004-06-uu/2004-07-03').from).to eq(Date.new(2004,6,1))
 			end
 			
 			it 'parses "2004?-06-11": uncertain year; month, day known' do
 				d = Parser.new.parse!('2004?-06-11')
-				d.uncertain?(:year).should be true
-				d.uncertain?([:month, :day]).should be false
+				expect(d.uncertain?(:year)).to be true
+				expect(d.uncertain?([:month, :day])).to be false
 			end
 
 			it 'parses "2004-06~-11": year and month are approximate; day known' do
 				d = Parser.new.parse!('2004-06~-11')
-				d.approximate?(:year).should be true
-				d.approximate?(:month).should be true
-				d.approximate?(:day).should be false
+				expect(d.approximate?(:year)).to be true
+				expect(d.approximate?(:month)).to be true
+				expect(d.approximate?(:day)).to be false
 			end
 			
 			it 'parses "2004-(06)?-11": uncertain month, year and day known' do
 				d = Parser.new.parse!('2004-(06)?-11')
 
-				d.uncertain?(:year).should be false
-				d.approximate?(:year).should be false
+				expect(d.uncertain?(:year)).to be false
+				expect(d.approximate?(:year)).to be false
 
-				d.uncertain?(:month).should be true
-				d.approximate?(:month).should be false
+				expect(d.uncertain?(:month)).to be true
+				expect(d.approximate?(:month)).to be false
 
-				d.uncertain?(:day).should be false
-				d.approximate?(:day).should be false
+				expect(d.uncertain?(:day)).to be false
+				expect(d.approximate?(:day)).to be false
 			end
 
 			it 'parses "2004-06-(11)~": day is approximate; year, month known' do
 				d = Parser.new.parse!('2004-06-(11)~')
-				d.approximate?(:year).should be false
-				d.approximate?(:month).should be false
-				d.approximate?(:day).should be true
+				expect(d.approximate?(:year)).to be false
+				expect(d.approximate?(:month)).to be false
+				expect(d.approximate?(:day)).to be true
 			end
 
 			it 'parses "2004-(06)?~": year known, month within year is approximate and uncertain' do
 				d = Parser.new.parse!('2004-(06)?~')
 								
-				d.approximate?(:year).should be false
-				d.uncertain?(:year).should be false
+				expect(d.approximate?(:year)).to be false
+				expect(d.uncertain?(:year)).to be false
 				
-				d.approximate?(:month).should be true
-				d.uncertain?(:month).should be true
+				expect(d.approximate?(:month)).to be true
+				expect(d.uncertain?(:month)).to be true
 				
-				d.approximate?(:day).should be false
-				d.uncertain?(:day).should be false
+				expect(d.approximate?(:day)).to be false
+				expect(d.uncertain?(:day)).to be false
 			end
 
 			it 'parses "2004-(06-11)?": year known, month and day uncertain' do
 				d = Parser.new.parse!('2004-(06-11)?')
 				
-				d.approximate?(:year).should be false
-				d.uncertain?(:year).should be false
+				expect(d.approximate?(:year)).to be false
+				expect(d.uncertain?(:year)).to be false
 				
-				d.approximate?(:month).should be false
-				d.uncertain?(:month).should be true
+				expect(d.approximate?(:month)).to be false
+				expect(d.uncertain?(:month)).to be true
 				
-				d.approximate?(:day).should be false
-				d.uncertain?(:day).should be true
+				expect(d.approximate?(:day)).to be false
+				expect(d.uncertain?(:day)).to be true
 			end
 
 			it 'parses "2004?-06-(11)~": year uncertain, month known, day approximate' do
 				d = Parser.new.parse('2004?-06-(11)~')
 				
-				d.approximate?(:year).should be false
-				d.uncertain?(:year).should be true
+				expect(d.approximate?(:year)).to be false
+				expect(d.uncertain?(:year)).to be true
 				
-				d.approximate?(:month).should be false
-				d.uncertain?(:month).should be false
+				expect(d.approximate?(:month)).to be false
+				expect(d.uncertain?(:month)).to be false
 				
-				d.approximate?(:day).should be true
-				d.uncertain?(:day).should be false
+				expect(d.approximate?(:day)).to be true
+				expect(d.uncertain?(:day)).to be false
 			end
 			
 			it 'parses "(2004-(06)~)?": year uncertain and month is both uncertain and approximate' do
 				d = Parser.new.parse!('(2004-(06)~)?')
 				
-				d.approximate?(:year).should be false
-				d.uncertain?(:year).should be true
+				expect(d.approximate?(:year)).to be false
+				expect(d.uncertain?(:year)).to be true
 				
-				d.approximate?(:month).should be true
-				d.uncertain?(:month).should be true
+				expect(d.approximate?(:month)).to be true
+				expect(d.uncertain?(:month)).to be true
 				
-				d.approximate?(:day).should be false
-				d.uncertain?(:day).should be false
+				expect(d.approximate?(:day)).to be false
+				expect(d.uncertain?(:day)).to be false
 			end
 
 			it 'parses "2004~-(06)?-01~": year and day approximate, month uncertain' do
 				d = Parser.new.parse!("2004~-(06)?-01~")
 				
-				d.approximate?(:year).should be true
-				d.uncertain?(:year).should be false
+				expect(d.approximate?(:year)).to be true
+				expect(d.uncertain?(:year)).to be false
 				
-				d.approximate?(:month).should be false
-				d.uncertain?(:month).should be true
+				expect(d.approximate?(:month)).to be false
+				expect(d.uncertain?(:month)).to be true
 				
-				d.approximate?(:day).should be true
-				d.uncertain?(:day).should be false
+				expect(d.approximate?(:day)).to be true
+				expect(d.uncertain?(:day)).to be false
 			end
 
 			it 'parses "2004~-(06-(01)~)?": year and day approximate, month and day uncertain' do
 				d = Parser.new.parse!("2004~-(06-(01)~)?")
 
-				d.approximate?(:year).should be true
-				d.uncertain?(:year).should be false
+				expect(d.approximate?(:year)).to be true
+				expect(d.uncertain?(:year)).to be false
 				
-				d.approximate?(:month).should be false
-				d.uncertain?(:month).should be true
+				expect(d.approximate?(:month)).to be false
+				expect(d.uncertain?(:month)).to be true
 				
-				d.approximate?(:day).should be true
-				d.uncertain?(:day).should be true
+				expect(d.approximate?(:day)).to be true
+				expect(d.uncertain?(:day)).to be true
 			end
 
 			it 'parses "2004~-(06)?-01?~": year and day approximate, month and day uncertain' do
 				d = Parser.new.parse!("2004~-(06)?-01?~")
 
-				d.approximate?(:year).should be true
-				d.uncertain?(:year).should be false
+				expect(d.approximate?(:year)).to be true
+				expect(d.uncertain?(:year)).to be false
 				
-				d.approximate?(:month).should be false
-				d.uncertain?(:month).should be true
+				expect(d.approximate?(:month)).to be false
+				expect(d.uncertain?(:month)).to be true
 				
-				d.approximate?(:day).should be true
-				d.uncertain?(:day).should be true
+				expect(d.approximate?(:day)).to be true
+				expect(d.uncertain?(:day)).to be true
 			end
 
 			it 'parses "2004~-(06)?": year approximate, month uncertain' do
 				d = Parser.new.parse!("2004~-(06)?")
 
-				d.approximate?(:year).should be true
-				d.uncertain?(:year).should be false
+				expect(d.approximate?(:year)).to be true
+				expect(d.uncertain?(:year)).to be false
 				
-				d.approximate?(:month).should be false
-				d.uncertain?(:month).should be true
+				expect(d.approximate?(:month)).to be false
+				expect(d.uncertain?(:month)).to be true
 				
-				d.approximate?(:day).should be false
-				d.uncertain?(:day).should be false
+				expect(d.approximate?(:day)).to be false
+				expect(d.uncertain?(:day)).to be false
 			end
 
 
 			it 'parses "2004~-06?": year approximate, year and month uncertain' do
 				d = Parser.new.parse!("2004~-06?")
 
-				d.approximate?(:year).should be true
-				d.uncertain?(:year).should be true
+				expect(d.approximate?(:year)).to be true
+				expect(d.uncertain?(:year)).to be true
 				
-				d.approximate?(:month).should be false
-				d.uncertain?(:month).should be true
+				expect(d.approximate?(:month)).to be false
+				expect(d.uncertain?(:month)).to be true
 				
-				d.approximate?(:day).should be false
-				d.uncertain?(:day).should be false
+				expect(d.approximate?(:day)).to be false
+				expect(d.uncertain?(:day)).to be false
 
 			end