edtf 0.0.6 → 0.0.7

data/spec/edtf/interval_spec.rb

@@ -1,12 +1,140 @@
 module EDTF
   describe 'Interval' do
-    describe 'when it ends in 2008' do
+    
+    describe 'the interval 2008/2011' do
+      let(:interval) { Date.edtf('2008/2011') }
 
-      let(:interval) { Interval.new(Date.new(2007), Date.new(2008)) }
+			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 'has a length of 4' do
+				interval.to_a.length.should == 4
+			end
+			
+			it '#step(2) yields the years 2008 and 2010' do
+				interval.step(2).map(&:year).should == [2008,2010]
+			end
+			
+			it 'the max date is 2011-12-31' do
+				interval.max.to_s.should == '2011-12-31'
+			end
+
+			it 'the max date has year precision' do
+				interval.max.should be_year_precision
+			end
+
+			it 'the min date is 2008-01-01' do
+				interval.min.to_s.should == '2008-01-01'
+			end
+
+			it 'the min date has year precision' do
+				interval.min.should be_year_precision
+			end
+			
+			
+      it 'includes the years 2008, 2009, 2010 and 2011' do
+        interval.to_a.map(&:year).should == [2008, 2009, 2010, 2011]
+      end
+      
+      it 'does not include christmas day 2009' do
+        interval.should_not include(Date.new(2009,12,24))
+      end
+
+ 			it 'christmas day 2009 is less than max' do
+				Date.new(2009,12,24).should < interval.max
+			end
+
+ 			it 'christmas day 2009 is greater than min' do
+				Date.new(2009,12,24).should > interval.min
+			end
+     
+      it 'covers christmas day 2009' do
+        interval.should cover(Date.new(2009,12,24))
+      end
+			
+      it 'covers 2011-12-31' do
+        interval.should cover(Date.new(2011,12,31))
+      end
+
+    end
+
+    describe 'the interval 2008-08-23/2011-07-01' do
+      let(:interval) { Date.edtf('2008-08-23/2011-07-01') }
+      
+      it 'includes christmas day 2009' do
+        interval.should include(Date.new(2009,12,24))
+      end
       
-      it 'should include any day in the year 2008' do
-        interval.should include(Date.new(2008, 12, 31))
+      it 'covers christmas day 2009' do
+        interval.should cover(Date.new(2009,12,24))
+      end
+
+      it 'does not cover 2011-07-02' do
+        interval.should_not 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 'the min date is 2008-08-23' do
+				interval.min.should == Date.new(2008,8,23)
+			end
+
+			it 'the max date is nil' do
+				interval.max.should be nil
+			end
+			
+      it 'includes christmas day 2009' do
+        interval.should include(Date.new(2009,12,24))
+      end
+      
+      it 'covers christmas day 2009' do
+        interval.should cover(Date.new(2009,12,24))
+      end
+
+      it 'covers 2023-07-02' do
+        interval.should 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')
+			end
+
+			it '2007/2009 should be less than 2011/2012' do
+				Date.edtf('2007/2009').should < Date.edtf('2011/2012')
+			end
+
+			it '2007/2009 should be less than 2008/2009' do
+				Date.edtf('2007/2009').should < Date.edtf('2008/2009')
+			end
+
+			it '2007/2009 should be greater than 2007/2008' do
+				Date.edtf('2007/2009').should > Date.edtf('2007/2008')
+			end
+
+			it '2007/2009 should be greater than 2006/2007' do
+				Date.edtf('2007/2009').should > Date.edtf('2006/2007')
+			end
+
+			it '2007/2009 should be equal to 2007/2009' do
+				Date.edtf('2007/2009').should == Date.edtf('2007/2009')
+			end
+
+
+			
+		end
   end
 end

data/spec/edtf/parser_spec.rb

@@ -23,9 +23,7 @@ module EDTF
       end
       
       it 'parses simple intervals like "2007/2008"' do
-        Parser.new.parse('2007/2008').should include(Date.new(2007,12,24))
-        Parser.new.parse('2007/2008').should include(Date.new(2008,1,2))
-        Parser.new.parse('2007/2008').should_not include(Date.new(2009,1,2))
+        Parser.new.parse('2007/2008').should be_a(Interval)
       end
    
       it 'parses uncertain dates' do
@@ -67,130 +65,139 @@ module EDTF
         Parser.new.parse('1984-06-02?/2004-08-08~').to.should be_approximate
       end
       
-      it 'should parse positive long years' do
+      it 'parses positive long years' do
         Parser.new.parse('y170000002').year.should == 170000002
       end
       
-      it 'should parse negative long years' do
+      it 'parses negative long years' do
         Parser.new.parse('y-170000002').year.should == -170000002
       end
       
-      it 'should parse season codes' do
+      it 'parses season codes' do
         Parser.new.parse('2003-23').should be_autumn
       end
 
-      it 'should parse calendar names' do
+      it 'parses calendar names' do
         Parser.new.parse('2001-02-03^xyz').calendar.should == 'xyz'
       end
       
-      it 'should parse season qualifiers' do
+      it 'parses season qualifiers' do
         d = Parser.new.parse('2003-23^european')
         d.should be_autumn
         d.should be_qualified
         d.qualifier.should == 'european'
       end
       
-      it 'should parse positive scientific long years' do
+      it 'parses positive scientific long years' do
         Parser.new.parse('y17e7').year.should == 170000000
       end
       
-      it 'should parse negative scientific long years' do
+      it 'parses negative scientific long years' do
         Parser.new.parse('y-17e7').year.should == -170000000        
       end
       
       it 'parses masked precision date strings (decades)' do
-        d = Parser.new.parse('198x')
+        d = Parser.new.parse!('198x')
         d.should include(Date.new(1983,3,12))
         d.should_not include(Date.new(1990,1,1))
       end
 
       it 'parses masked precision date strings (centuries)' do
-        d = Parser.new.parse('18xx')
+        d = Parser.new.parse!('18xx')
         d.should include(Date.new(1848,1,14))
         d.should_not include(Date.new(1799,12,31))
       end
       
       it 'parses multiple dates (years)' do
-        d = Parser.new.parse('{1667,1668, 1670..1672}')
+        d = Parser.new.parse!('{1667,1668, 1670..1672}')
         d.map(&:year).should == [1667,1668,1670,1671,1672]
       end
       
       it 'parses multiple dates (mixed years and months)' do
-        d = Parser.new.parse('{1960, 1961-12}')
+        d = Parser.new.parse!('{1960, 1961-12}')
         d.map { |x| [x.year,x.month] }.should == [[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 = Parser.new.parse!('[1667,1668, 1670..1672]')
         d.map(&:year).should == [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 = Parser.new.parse!('[..1760-12-03]')
         d.map(&:to_s).should == ['1760-12-03']
       end
 
       it 'parses choice lists (December 1760 or some later month)' do
-        d = Parser.new.parse('[1760-12..]')
+        d = Parser.new.parse!('[1760-12..]')
         d.map { |x| [x.year,x.month] }.should == [[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 = Parser.new.parse!('[1760-01, 1760-02, 1760-12..]')
         d.length.should == 3
       end
       
       it 'parses intern unspecified "199u-01-01"' do
-        Parser.new.parse('199u-01-01').unspecified.to_s.should == 'sssu-ss-ss'
+        Parser.new.parse!('199u-01-01').unspecified.to_s.should == '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'
+        Parser.new.parse!('19uu-01-01').unspecified.to_s.should == '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'
+        Parser.new.parse!('199u-uu-01').unspecified.to_s.should == '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'
+        Parser.new.parse!('19uu-uu-01').unspecified.to_s.should == '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'
+        Parser.new.parse!('199u-uu-uu').unspecified.to_s.should == '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'
+        Parser.new.parse!('19uu-uu-uu').unspecified.to_s.should == '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'
+        Parser.new.parse!('199u-01-uu').unspecified.to_s.should == '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'
+        Parser.new.parse!('19uu-01-uu').unspecified.to_s.should == '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'
+        Parser.new.parse!('1999-uu-01').unspecified.to_s.should == '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'
+      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)
+			end
+			
 			it 'parses "2004?-06-11": uncertain year; month, day known' do
-				d = Parser.new.parse('2004?-06-11')
+				d = Parser.new.parse!('2004?-06-11')
 				d.uncertain?(:year).should be true
 				d.uncertain?([:month, :day]).should be false
 			end
 
 			it 'parses "2004-06~-11": year and month are approximate; day known' do
-				d = Parser.new.parse('2004-06~-11')
+				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
 			end
 			
 			it 'parses "2004-(06)?-11": uncertain month, year and day known' do
-				d = Parser.new.parse('2004-(06)?-11')
+				d = Parser.new.parse!('2004-(06)?-11')
 
 				d.uncertain?(:year).should be false
 				d.approximate?(:year).should be false
@@ -203,15 +210,15 @@ module EDTF
 			end
 
 			it 'parses "2004-06-(11)~": day is approximate; year, month known' do
-				d = Parser.new.parse('2004-06-(11)~')
+				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
 			end
 
 			it 'parses "2004-(06)?~": year known, month within year is approximate and uncertain' do
-				d = Parser.new.parse('2004-(06)?~')
-				
+				d = Parser.new.parse!('2004-(06)?~')
+								
 				d.approximate?(:year).should be false
 				d.uncertain?(:year).should be false
 				
@@ -223,7 +230,7 @@ module EDTF
 			end
 
 			it 'parses "2004-(06-11)?": year known, month and day uncertain' do
-				d = Parser.new.parse('2004-(06-11)?')
+				d = Parser.new.parse!('2004-(06-11)?')
 				
 				d.approximate?(:year).should be false
 				d.uncertain?(:year).should be false
@@ -249,7 +256,7 @@ module EDTF
 			end
 			
 			it 'parses "(2004-(06)~)?": year uncertain and month is both uncertain and approximate' do
-				d = Parser.new.parse('(2004-(06)~)?')
+				d = Parser.new.parse!('(2004-(06)~)?')
 				
 				d.approximate?(:year).should be false
 				d.uncertain?(:year).should be true
@@ -261,6 +268,20 @@ module EDTF
 				d.uncertain?(:day).should be false
 			end
 
+			it 'parses "2004~-(06)?-01~": year and day approximate, month uncertain' do
+				d = Parser.new.parse!("2004~-(06)?-01~")
+			end
+
+			it 'parses "2004~-(06-(01)~)?": year and day approximate, month and day uncertain' do
+				d = Parser.new.parse!("2004~-(06-(01)~)?")
+			end
+
+			it 'parses "2004~-(06)?-01?~": year and day approximate, month and day uncertain' do
+				d = Parser.new.parse!("2004~-(06)?-01?~")
+			end
+
+		 
+
     end
   end
 end

data/spec/edtf/uncertainty_spec.rb

@@ -13,14 +13,15 @@ module EDTF
       end
 
       it 'should not be uncertain if all parts are certain' do
-        Uncertainty.new(false, false, false, false, false, false).should be_certain
+        Uncertainty.new(false, false, false).should be_certain
       end
 
       it 'should be uncertain if all parts are uncertain' do
-        Uncertainty.new(true, true, true, true, true, true).should be_uncertain
+        Uncertainty.new(true, true, true).should be_uncertain
       end
 
-      [:year, :month, :day, :hour, :minute, :second].each do |part|
+      # [: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
         end
@@ -30,12 +31,53 @@ module EDTF
           uncertainty.uncertain?(part).should be true
         end
         
-        ([:year, :month, :day, :hour, :minute, :second] - [part]).each do |other|
+        # ([: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
           end
         end
+
+      end
+
+      describe '#hash' do
+        
+        describe 'with the default hash base (1)' do
+
+          it 'returns 0 by default' do
+            Uncertainty.new.hash.should == 0
+          end
+          
+          it 'returns 1 for uncertain year' do
+            Uncertainty.new.hash.should == 0
+          end
+
+          it 'returns 2 for uncertain month' do
+            Uncertainty.new.hash.should == 0
+          end
+
+          it 'returns 4 for uncertain day' do
+            Uncertainty.new.hash.should == 0
+          end
+
+          it 'returns 3 for uncertain year, month' do
+            Uncertainty.new(true, true).hash.should == 3
+          end
+
+          it 'returns 7 for uncertain year, month, day' do
+            Uncertainty.new(true, true, true).hash.should == 7
+          end
+
+          it 'returns 5 for uncertain year, day' do
+            Uncertainty.new(true, nil, true).hash.should == 5
+          end
+
+          it 'returns 6 for uncertain month, day' do
+            Uncertainty.new(nil, true, true).hash.should == 6
+          end
+          
+        end
         
       end
       
@@ -108,6 +150,127 @@ module EDTF
       end
       
     end
+
+		describe '#mask' do
+			
+			context 'when passed an empty array' do
+				it 'should return an empty array' do
+					u.mask([]).should == []
+				end
+			end
+			
+			context 'when passed an array with a year string' do
+				let(:date) { ['1994'] }
+				
+				it 'should return the array with the year by default' do
+					u.mask(date).should == ['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']
+					end
+					
+				end
+
+				context 'when the decade is unspecified' do
+					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']
+					end
+					
+				end
+				
+			end
+			
+			context 'when passed an array with a year-month string' do
+				let(:date) { ['1994', '01'] }
+				
+				it 'should return the array with the year by default' do
+					u.mask(date).should == ['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']
+					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']
+						end		
+					end
+				end
+
+				context 'when the decade is unspecified' do
+					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']
+					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']
+						end		
+					end			
+				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 == ['1994', 'uu']
+					end		
+				end				
+
+			end
+			
+			context 'when passed an array with a year-month-day string' do
+				let(:date) { ['1994', '01', '27'] }
+				
+				it 'should return the array with the date by default' do
+					u.mask(date).should == ['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']
+					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']
+						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']
+							end		
+						end
+					end
+				end
+			
+			
+			end
+			
+			
+		end
     
   end