edtf 2.1.0 → 2.2.0

data/spec/edtf/season_spec.rb

@@ -8,26 +8,26 @@ module EDTF
     describe 'uncertain/approximate' do
 
       it 'is certain by default' do
-        subject.should be_certain
-        subject.should_not be_uncertain
+        expect(subject).to be_certain
+        expect(subject).not_to be_uncertain
       end
 
       it 'is precise by default' do
-        subject.should be_precise
-        subject.should_not be_approximate
+        expect(subject).to be_precise
+        expect(subject).not_to be_approximate
       end
 
       describe '#approximate!' do
         it 'makes the season approximate' do
-          subject.approximate!.should be_approximate
-          subject.approximate!.should_not be_precise
+          expect(subject.approximate!).to be_approximate
+          expect(subject.approximate!).not_to be_precise
         end
       end
 
       describe '#uncertain!' do
         it 'makes the season uncertain' do
-          subject.uncertain!.should be_uncertain
-          subject.uncertain!.should_not be_certain
+          expect(subject.uncertain!).to be_uncertain
+          expect(subject.uncertain!).not_to be_certain
         end
       end
 
@@ -36,24 +36,24 @@ module EDTF
     describe '#succ' do
 
       it 'returns a season' do
-        summer.succ.should be_instance_of(Season)
+        expect(summer.succ).to be_instance_of(Season)
       end
 
       it 'it returns a season that is greater than the original one' do
-        summer.succ.should > summer
+        expect(summer.succ).to be > summer
       end
 
       it 'the successor of the winter season is spring of the following year' do
         spring = winter.succ
-        spring.should be_spring
-        spring.year.should == winter.year + 1
+        expect(spring).to be_spring
+        expect(spring.year).to eq(winter.year + 1)
       end
 
     end
 
     describe '#season?' do
       it 'returns true by default' do
-        subject.should be_season
+        expect(subject).to be_season
       end
     end
 
@@ -61,38 +61,39 @@ module EDTF
       before(:each) { subject.season = :summer }
 
       it 'returns the season code' do
-        subject.season.should == :summer
+        expect(subject.season).to eq(:summer)
       end
     end
 
     describe '#season=' do
       it 'sets the season code when called with a valid season code' do
-        lambda {
+        expect {
           (21..22).each do |i|
             subject.season = i
           end
-        }.should_not raise_error
+        }.not_to raise_error
       end
 
       it 'throws an exception if given invalid season code' do
-        lambda { subject.season = 13 }.should raise_error
+        expect { subject.season = 13 }.to raise_error
       end
     end
 
     describe '#summer!' do
       it 'sets the season to :summer' do
-        lambda { subject.summer! }.should change { subject.season }.to(:summer)
+        subject.season = :spring
+        expect { subject.summer! }.to change { subject.season }.to(:summer)
       end
     end
 
     describe '#winter?' do
       it 'returns true if the season is set to :winter' do
         subject.season = :winter
-        subject.should be_winter
+        expect(subject).to be_winter
       end
       it 'returns false if the season is not set to :winter' do
         subject.season = :summer
-        subject.should_not be_winter
+        expect(subject).not_to be_winter
       end
     end
 
@@ -100,7 +101,7 @@ module EDTF
 
       context 'for summer' do
         it 'returns true for August 24' do
-          Season.new(1980, :summer).should include(Date.new(1980,8,24))
+          expect(Season.new(1980, :summer)).to include(Date.new(1980,8,24))
         end
       end
 

data/spec/edtf/set_spec.rb

@@ -1,73 +1,73 @@
 module EDTF
   describe 'Sets' do
-	
-		describe 'constructor' do
-			
-			it 'creates a new empty set by default' do
-				Set.new.should be_empty
-			end
-			
-		end
-	
-		describe '#edtf' do
-			
-			it 'returns {} by default' do
-				Set.new.edtf.should == '{}'
-			end
-
-			it 'returns [] for empty choice lists' do
-				Set.new.choice!.edtf.should == '[]'
-			end
-			
-			it 'returns {1984} if the set contains the year 1984' do
-				Set.new(Date.edtf('1984')).edtf.should == '{1984}'
-			end
-			
-			it 'returns {1984, 1985-10} for the set containing these dates' do
-				Set.new(Date.edtf('1984'), Date.new(1984,10).month_precision).edtf.should == '{1984, 1984-10}'
-			end
-
-			it 'returns {..1984, 1985-10} for the set containing these dates and earlier == true' do
-				Set.new(Date.edtf('1984'), Date.new(1984,10).month_precision).earlier!.edtf.should == '{..1984, 1984-10}'
-			end
-
-			it 'returns {1984, 1985-10..} for the set containing these dates and later == true' do
-				Set.new(Date.edtf('1984'), Date.new(1984,10).month_precision).later!.edtf.should == '{1984, 1984-10..}'
-			end
-
-			it 'returns [1667, 1668, 1670..1672] for the years 1667, 1668 and the interval 1670..1672' do
-				s = Set.new.choice!
-				s << Date.edtf('1667') << Date.edtf('1668')
-				s << (Date.edtf('1670') .. Date.edtf('1672'))
-				s.edtf.should == '[1667, 1668, 1670..1672]'
-			end
-			
-		end
-		
-		describe 'the set [1667, 1668, 1670..1672]' do
-			let(:set) { Set.new(Date.edtf('1667'), Date.edtf('1668'), Date.edtf('1670')..Date.edtf('1672')).choice! }
-		
-			it 'includes the year 1671' do
-				set.should include(Date.new(1671).year_precision!)
-			end
-
-			it 'does not include the date 1671-01-01' do
-				set.should_not include(Date.new(1671))
-			end
-
-			it 'does not include the year 1669' do
-				set.should_not include(Date.new(1669).year_precision!)
-			end
-			
-			it 'has a length of 3' do
-				set.should have(3).elements
-			end
-			
-			it 'maps to the year array [1667, 1668, 1670, 1671, 1672]' do
-				set.map(&:year).should == [1667, 1668, 1670, 1671, 1672]
-			end
-		
-		end
-		
-	end
-end
+
+    describe 'constructor' do
+
+      it 'creates a new empty set by default' do
+        expect(Set.new).to be_empty
+      end
+
+    end
+
+    describe '#edtf' do
+
+      it 'returns {} by default' do
+        expect(Set.new.edtf).to eq('{}')
+      end
+
+      it 'returns [] for empty choice lists' do
+        expect(Set.new.choice!.edtf).to eq('[]')
+      end
+
+      it 'returns {1984} if the set contains the year 1984' do
+        expect(Set.new(Date.edtf('1984')).edtf).to eq('{1984}')
+      end
+
+      it 'returns {1984, 1985-10} for the set containing these dates' do
+        expect(Set.new(Date.edtf('1984'), Date.new(1984,10).month_precision).edtf).to eq('{1984,1984-10}')
+      end
+
+      it 'returns {..1984, 1985-10} for the set containing these dates and earlier == true' do
+        expect(Set.new(Date.edtf('1984'), Date.new(1984,10).month_precision).earlier!.edtf).to eq('{..1984,1984-10}')
+      end
+
+      it 'returns {1984, 1985-10..} for the set containing these dates and later == true' do
+        expect(Set.new(Date.edtf('1984'), Date.new(1984,10).month_precision).later!.edtf).to eq('{1984,1984-10..}')
+      end
+
+      it 'returns [1667, 1668, 1670..1672] for the years 1667, 1668 and the interval 1670..1672' do
+        s = Set.new.choice!
+        s << Date.edtf('1667') << Date.edtf('1668')
+        s << (Date.edtf('1670') .. Date.edtf('1672'))
+        expect(s.edtf).to eq('[1667,1668,1670..1672]')
+      end
+
+    end
+
+    describe 'the set [1667, 1668, 1670..1672]' do
+      let(:set) { Set.new(Date.edtf('1667'), Date.edtf('1668'), Date.edtf('1670')..Date.edtf('1672')).choice! }
+
+      it 'includes the year 1671' do
+        expect(set).to include(Date.new(1671).year_precision!)
+      end
+
+      it 'does not include the date 1671-01-01' do
+        expect(set.include?(Date.new(1671))).to be false
+      end
+
+      it 'does not include the year 1669' do
+        expect(set.include?(Date.new(1669).year_precision!)).to be false
+      end
+
+      it 'has a length of 3' do
+        expect(set.size).to eq(3)
+      end
+
+      it 'maps to the year array [1667,1668,1670,1671,1672]' do
+        expect(set.map(&:year)).to eq([1667, 1668, 1670, 1671, 1672])
+      end
+
+    end
+
+  end
+end

data/spec/edtf/uncertainty_spec.rb

@@ -6,36 +6,36 @@ module EDTF
     
     describe '#uncertain?' do
       
-      it { should be_certain }
+      it { is_expected.to be_certain }
 
       it 'should be uncertain if at least one part is uncertain' do
-        Uncertainty.new(false, false, true).should be_uncertain
+        expect(Uncertainty.new(false, false, true)).to be_uncertain
       end
 
       it 'should not be uncertain if all parts are certain' do
-        Uncertainty.new(false, false, false).should be_certain
+        expect(Uncertainty.new(false, false, false)).to be_certain
       end
 
       it 'should be uncertain if all parts are uncertain' do
-        Uncertainty.new(true, true, true).should be_uncertain
+        expect(Uncertainty.new(true, true, true)).to be_uncertain
       end
 
       # [:year, :month, :day, :hour, :minute, :second].each do |part|
       [:year, :month, :day].each do |part|
         it "#{ part } should not be uncertain by default" do
-          uncertainty.uncertain?(part).should be false
+          expect(uncertainty.uncertain?(part)).to be false
         end
 
         it "#{ part } should be uncertain if set to uncertain" do
           uncertainty.send("#{part}=", true)
-          uncertainty.uncertain?(part).should be true
+          expect(uncertainty.uncertain?(part)).to be true
         end
         
         # ([:year, :month, :day, :hour, :minute, :second] - [part]).each do |other|
         ([:year, :month, :day] - [part]).each do |other|
           it "#{other} should not be uncertain if #{part} is uncertain" do
             uncertainty.send("#{part}=", true)
-            uncertainty.uncertain?(other).should be false
+            expect(uncertainty.uncertain?(other)).to be false
           end
         end
 
@@ -46,35 +46,35 @@ module EDTF
         describe 'with the default hash base (1)' do
 
           it 'returns 0 by default' do
-            Uncertainty.new.hash.should == 0
+            expect(Uncertainty.new.hash).to eq(0)
           end
           
           it 'returns 1 for uncertain year' do
-            Uncertainty.new.hash.should == 0
+            expect(Uncertainty.new.hash).to eq(0)
           end
 
           it 'returns 2 for uncertain month' do
-            Uncertainty.new.hash.should == 0
+            expect(Uncertainty.new.hash).to eq(0)
           end
 
           it 'returns 4 for uncertain day' do
-            Uncertainty.new.hash.should == 0
+            expect(Uncertainty.new.hash).to eq(0)
           end
 
           it 'returns 3 for uncertain year, month' do
-            Uncertainty.new(true, true).hash.should == 3
+            expect(Uncertainty.new(true, true).hash).to eq(3)
           end
 
           it 'returns 7 for uncertain year, month, day' do
-            Uncertainty.new(true, true, true).hash.should == 7
+            expect(Uncertainty.new(true, true, true).hash).to eq(7)
           end
 
           it 'returns 5 for uncertain year, day' do
-            Uncertainty.new(true, nil, true).hash.should == 5
+            expect(Uncertainty.new(true, nil, true).hash).to eq(5)
           end
 
           it 'returns 6 for uncertain month, day' do
-            Uncertainty.new(nil, true, true).hash.should == 6
+            expect(Uncertainty.new(nil, true, true).hash).to eq(6)
           end
           
         end
@@ -85,7 +85,7 @@ module EDTF
     
     describe '#uncertain!' do
       it 'should make all parts certain when no part given' do
-        lambda { uncertainty.uncertain! }.should change { uncertainty.certain? }
+        expect { uncertainty.uncertain! }.to change { uncertainty.certain? }
       end
     end
     
@@ -97,56 +97,56 @@ module EDTF
     
     describe '#unspecified?' do
       it 'should return false by default' do
-        u.should_not be_unspecified
+        expect(u).not_to be_unspecified
       end
       
       it 'should return true if the day is unspecified' do
-        u.unspecified!(:day).should be_unspecified
+        expect(u.unspecified!(:day)).to be_unspecified
       end
 
       it 'should return true if the month is unspecified' do
-        u.unspecified!(:month).should be_unspecified
+        expect(u.unspecified!(:month)).to be_unspecified
       end
 
       it 'should return true if the year is unspecified' do
-        u.unspecified!(:year).should be_unspecified
+        expect(u.unspecified!(:year)).to be_unspecified
       end
     end
     
     describe '#year' do
       it 'returns the year values' do
-        u.year.should == [nil,nil,nil,nil]
+        expect(u.year).to eq([nil,nil,nil,nil])
       end
       
       it 'allows you to set individual offsets' do
         u.year[1] = true
-        u.to_s.should == 'suss-ss-ss'
+        expect(u.to_s).to eq('suss-ss-ss')
       end
     end
     
     describe '#to_s' do
       it 'should be return "ssss-ss-ss" by default' do
-        u.to_s.should == 'ssss-ss-ss'
+        expect(u.to_s).to eq('ssss-ss-ss')
       end
       
       it 'should return "ssss-ss-uu" if the day is unspecified' do
-        u.unspecified!(:day).to_s.should == 'ssss-ss-uu'
+        expect(u.unspecified!(:day).to_s).to eq('ssss-ss-uu')
       end
 
       it 'should return "ssss-uu-ss" if the month is unspecified' do
-        u.unspecified!(:month).to_s.should == 'ssss-uu-ss'
+        expect(u.unspecified!(:month).to_s).to eq('ssss-uu-ss')
       end
 
       it 'should return "ssss-uu-uu" if month and day are unspecified' do
-        u.unspecified!([:day, :month]).to_s.should == 'ssss-uu-uu'
+        expect(u.unspecified!([:day, :month]).to_s).to eq('ssss-uu-uu')
       end
 
       it 'should return "uuuu-ss-ss" if the year is unspecified' do
-        u.unspecified!(:year).to_s.should == 'uuuu-ss-ss'
+        expect(u.unspecified!(:year).to_s).to eq('uuuu-ss-ss')
       end
 
       it 'should return "uuuu-uu-uu" if the date is unspecified' do
-        u.unspecified!.to_s.should == 'uuuu-uu-uu'
+        expect(u.unspecified!.to_s).to eq('uuuu-uu-uu')
       end
       
     end
@@ -155,7 +155,7 @@ module EDTF
 			
 			context 'when passed an empty array' do
 				it 'should return an empty array' do
-					u.mask([]).should == []
+					expect(u.mask([])).to eq([])
 				end
 			end
 			
@@ -163,14 +163,14 @@ module EDTF
 				let(:date) { ['1994'] }
 				
 				it 'should return the array with the year by default' do
-					u.mask(date).should == ['1994']
+					expect(u.mask(date)).to eq(['1994'])
 				end
 				
 				context 'when the year is unspecified' do
 					before(:each) { u.year[3] = true }
 					
 					it 'should return the array with the year and the fourth digit masked' do
-						u.mask(date).should == ['199u']
+						expect(u.mask(date)).to eq(['199u'])
 					end
 					
 				end
@@ -179,7 +179,7 @@ module EDTF
 					before(:each) { u.year[2,2] = [true,true] }
 					
 					it 'should return the array with the year and the third and fourth digit masked' do
-						u.mask(date).should == ['19uu']
+						expect(u.mask(date)).to eq(['19uu'])
 					end
 					
 				end
@@ -190,21 +190,21 @@ module EDTF
 				let(:date) { ['1994', '01'] }
 				
 				it 'should return the array with the year by default' do
-					u.mask(date).should == ['1994', '01']
+					expect(u.mask(date)).to eq(['1994', '01'])
 				end
 
 				context 'when the year is unspecified' do
 					before(:each) { u.year[3] = true }
 					
 					it 'should return the array with the year and the fourth digit masked' do
-						u.mask(date).should == ['199u', '01']
+						expect(u.mask(date)).to eq(['199u', '01'])
 					end
 					
 					context 'when the month is unspecified' do
 						before(:each) { u.unspecified! :month }
 
 						it 'should return the array with the month masked' do
-							u.mask(date).should == ['199u', 'uu']
+							expect(u.mask(date)).to eq(['199u', 'uu'])
 						end		
 					end
 				end
@@ -213,14 +213,14 @@ module EDTF
 					before(:each) { u.year[2,2] = [true,true] }
 					
 					it 'should return the array with the year and the third and fourth digit masked' do
-						u.mask(date).should == ['19uu', '01']
+						expect(u.mask(date)).to eq(['19uu', '01'])
 					end
 					
 					context 'when the month is unspecified' do
 						before(:each) { u.unspecified! :month }
 
 						it 'should return the array with the month masked' do
-							u.mask(date).should == ['19uu', 'uu']
+							expect(u.mask(date)).to eq(['19uu', 'uu'])
 						end		
 					end			
 				end
@@ -229,7 +229,7 @@ module EDTF
 					before(:each) { u.unspecified! :month }
 					
 					it 'should return the array with the month masked' do
-						u.mask(date).should == ['1994', 'uu']
+						expect(u.mask(date)).to eq(['1994', 'uu'])
 					end		
 				end				
 
@@ -239,28 +239,28 @@ module EDTF
 				let(:date) { ['1994', '01', '27'] }
 				
 				it 'should return the array with the date by default' do
-					u.mask(date).should == ['1994', '01', '27']
+					expect(u.mask(date)).to eq(['1994', '01', '27'])
 				end
 			
 				context 'when the year is unspecified' do
 					before(:each) { u.year[3] = true }
 					
 					it 'should return the array with the year and the fourth digit masked' do
-						u.mask(date).should == ['199u', '01', '27']
+						expect(u.mask(date)).to eq(['199u', '01', '27'])
 					end
 					
 					context 'when the month is unspecified' do
 						before(:each) { u.unspecified! :month }
 
 						it 'should return the array with the month masked' do
-							u.mask(date).should == ['199u', 'uu', '27']
+							expect(u.mask(date)).to eq(['199u', 'uu', '27'])
 						end		
 						
 						context 'when the day is unspecified' do
 							before(:each) { u.unspecified! :day }
 
 							it 'should return the array with the month masked' do
-								u.mask(date).should == ['199u', 'uu', 'uu']
+								expect(u.mask(date)).to eq(['199u', 'uu', 'uu'])
 							end		
 						end
 					end