edtf 3.3.0 → 4.0.0

data/spec/edtf/parser_spec.rb

@@ -1,427 +0,0 @@
-module EDTF
-  describe Parser do
-    describe '#parse' do
-
-      it 'parses simple dates "2001-02-03"' do
-        expect(Parser.new.parse('2001-02-03').to_s).to eq('2001-02-03')
-      end
-
-      it 'parses negative years' do
-        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
-				expect(Parser.new.parse('-2101')).to be_year_precision
-			end
-
-      it 'parses year zero' do
-        expect(Parser.new.parse('0000').to_s).to eq('0000-01-01')
-      end
-
-      it 'parses date/time with time zones' do
-        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
-        expect(Parser.new.parse('2007/2008')).to be_a(Interval)
-      end
-
-      it 'parses uncertain dates' do
-        expect(Parser.new.parse('1984?')).to be_uncertain
-        expect(Parser.new.parse('1984')).to be_certain
-      end
-
-      it 'parses uncertain dates (day precision)' do
-        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
-        expect(Parser.new.parse('1984-01~')).to be_approximate
-        expect(Parser.new.parse('1984-01')).to be_precise
-      end
-
-      it 'parses draft spec uncertain approximate dates' do
-        expect(Parser.new.parse('1984?~')).to be_uncertain
-        expect(Parser.new.parse('1984?~')).to be_approximate
-      end
-
-      it 'parses final spec uncertain approximate dates' do
-        expect(Parser.new.parse('1984%')).to be_uncertain
-        expect(Parser.new.parse('1984%')).to be_approximate
-      end
-
-      it 'parses draft spec unspecified dates' do
-        expect(Parser.new.parse('199u')).to be_unspecified
-        expect(Parser.new.parse('1999-uu-uu')).to be_unspecified
-        expect(Parser.new.parse('199u-01')).to be_unspecified
-      end
-
-      it 'parses final spec unspecified dates' do
-        expect(Parser.new.parse('199X')).to be_unspecified
-        expect(Parser.new.parse('1999-XX-XX')).to be_unspecified
-        expect(Parser.new.parse('199X-01')).to be_unspecified
-      end
-
-      it 'parses draft spec negative unspecified dates' do
-        expect(Parser.new.parse('-199u')).to be_unspecified
-        expect(Parser.new.parse('-1999-uu-uu')).to be_unspecified
-      end
-
-      it 'parses final spec negative unspecified dates' do
-        expect(Parser.new.parse('-199X')).to be_unspecified
-        expect(Parser.new.parse('-1999-XX-XX')).to be_unspecified
-      end
-
-      it 'parses open intervals' do
-        expect(Parser.new.parse('2004-01-01/open')).to be_open
-      end
-
-      it 'parses unknown intervals' do
-        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
-        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
-        expect(Parser.new.parse('y170000002').year).to eq(170000002)
-      end
-
-      it 'parses negative long years' do
-        expect(Parser.new.parse('y-170000002').year).to eq(-170000002)
-      end
-
-      it 'parses season codes' do
-        expect(Parser.new.parse('2003-23')).to be_autumn
-      end
-
-      it 'parses calendar names' do
-        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')
-        expect(d).to be_autumn
-        expect(d).to be_qualified
-        expect(d.qualifier).to eq('european')
-      end
-
-			it 'parses uncertain seasons' do
-        expect(Parser.new.parse!('2003-23?')).to be_uncertain
-			end
-
-			it 'parses approximate seasons' do
-        expect(Parser.new.parse!('2003-23~')).to be_approximate
-			end
-
-			it 'parses draft spec uncertain and approximate seasons' do
-        expect(Parser.new.parse!('2003-23?~')).to be_uncertain
-        expect(Parser.new.parse!('2003-23?~')).to be_approximate
-			end
-
-      it 'parses final spec uncertain and approximate seasons' do
-        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
-        expect(Parser.new.parse('y17e7').year).to eq(170000000)
-        expect(Parser.new.parse('Y17E7').year).to eq(170000000)
-      end
-
-      it 'parses negative scientific long years' do
-        expect(Parser.new.parse('y-17e7').year).to eq(-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')
-        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')
-        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}')
-        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}')
-        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]')
-        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]')
-        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..]')
-        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..]')
-        expect(d.length).to eq(3)
-      end
-
-      it 'parses intern unspecified "199u-01-01"' do
-        expect(Parser.new.parse!('199u-01-01').unspecified.to_s).to eq('sssX-ss-ss')
-      end
-
-      it 'parses intern unspecified "19uu-01-01"' do
-        expect(Parser.new.parse!('19uu-01-01').unspecified.to_s).to eq('ssXX-ss-ss')
-      end
-
-      it 'parses intern unspecified "199u-uu-01"' do
-        expect(Parser.new.parse!('199u-uu-01').unspecified.to_s).to eq('sssX-XX-ss')
-      end
-
-      it 'parses intern unspecified "19uu-uu-01"' do
-        expect(Parser.new.parse!('19uu-uu-01').unspecified.to_s).to eq('ssXX-XX-ss')
-      end
-
-      it 'parses intern unspecified "199u-uu-uu"' do
-        expect(Parser.new.parse!('199u-uu-uu').unspecified.to_s).to eq('sssX-XX-XX')
-      end
-
-      it 'parses intern unspecified "19uu-uu-uu"' do
-        expect(Parser.new.parse!('19uu-uu-uu').unspecified.to_s).to eq('ssXX-XX-XX')
-      end
-
-      it 'parses intern unspecified "199u-01-uu"' do
-        expect(Parser.new.parse!('199u-01-uu').unspecified.to_s).to eq('sssX-ss-XX')
-      end
-
-      it 'parses intern unspecified "19uu-01-uu"' do
-        expect(Parser.new.parse!('19uu-01-uu').unspecified.to_s).to eq('ssXX-ss-XX')
-      end
-
-      it 'parses intern unspecified "1999-uu-01"' do
-        expect(Parser.new.parse!('1999-uu-01').unspecified.to_s).to eq('ssss-XX-ss')
-      end
-
-      it 'parses intern unspecified "2004-06-uu"' do
-        expect(Parser.new.parse!('2004-06-uu').unspecified.to_s).to eq('ssss-ss-XX')
-      end
-
-			it 'parses internal unspecified interval  "2004-06-uu/2004-07-03"' do
-				expect(Parser.new.parse!('2004-06-uu/2004-07-03').from).to eq(Date.new(2004,6,1))
-			end
-
-      it 'parses intern unspecified "199X-01-01"' do
-        expect(Parser.new.parse!('199X-01-01').unspecified.to_s).to eq('sssX-ss-ss')
-      end
-
-      it 'parses intern unspecified "19XX-01-01"' do
-        expect(Parser.new.parse!('19XX-01-01').unspecified.to_s).to eq('ssXX-ss-ss')
-      end
-
-      it 'parses intern unspecified "199X-XX-01"' do
-        expect(Parser.new.parse!('199X-XX-01').unspecified.to_s).to eq('sssX-XX-ss')
-      end
-
-      it 'parses intern unspecified "19XX-XX-01"' do
-        expect(Parser.new.parse!('19XX-XX-01').unspecified.to_s).to eq('ssXX-XX-ss')
-      end
-
-      it 'parses intern unspecified "199X-XX-XX"' do
-        expect(Parser.new.parse!('199X-XX-XX').unspecified.to_s).to eq('sssX-XX-XX')
-      end
-
-      it 'parses intern unspecified "19XX-XX-XX"' do
-        expect(Parser.new.parse!('19XX-XX-XX').unspecified.to_s).to eq('ssXX-XX-XX')
-      end
-
-      it 'parses intern unspecified "199X-01-XX"' do
-        expect(Parser.new.parse!('199X-01-XX').unspecified.to_s).to eq('sssX-ss-XX')
-      end
-
-      it 'parses intern unspecified "19XX-01-XX"' do
-        expect(Parser.new.parse!('19XX-01-XX').unspecified.to_s).to eq('ssXX-ss-XX')
-      end
-
-      it 'parses intern unspecified "1999-XX-01"' do
-        expect(Parser.new.parse!('1999-XX-01').unspecified.to_s).to eq('ssss-XX-ss')
-      end
-
-      it 'parses intern unspecified "2004-06-XX"' do
-        expect(Parser.new.parse!('2004-06-XX').unspecified.to_s).to eq('ssss-ss-XX')
-      end
-
-			it 'parses internal unspecified interval  "2004-06-XX/2004-07-03"' do
-				expect(Parser.new.parse!('2004-06-XX/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')
-				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')
-				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')
-
-				expect(d.uncertain?(:year)).to be false
-				expect(d.approximate?(:year)).to be false
-
-				expect(d.uncertain?(:month)).to be true
-				expect(d.approximate?(:month)).to 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)~')
-				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)?~')
-
-				expect(d.approximate?(:year)).to be false
-				expect(d.uncertain?(:year)).to be false
-
-				expect(d.approximate?(:month)).to be true
-				expect(d.uncertain?(:month)).to be true
-
-				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)?')
-
-				expect(d.approximate?(:year)).to be false
-				expect(d.uncertain?(:year)).to be false
-
-				expect(d.approximate?(:month)).to be false
-				expect(d.uncertain?(:month)).to 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)~')
-
-				expect(d.approximate?(:year)).to be false
-				expect(d.uncertain?(:year)).to be true
-
-				expect(d.approximate?(:month)).to be false
-				expect(d.uncertain?(:month)).to 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)~)?')
-
-				expect(d.approximate?(:year)).to be false
-				expect(d.uncertain?(:year)).to be true
-
-				expect(d.approximate?(:month)).to be true
-				expect(d.uncertain?(:month)).to be true
-
-				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~")
-
-				expect(d.approximate?(:year)).to be true
-				expect(d.uncertain?(:year)).to be false
-
-				expect(d.approximate?(:month)).to be false
-				expect(d.uncertain?(:month)).to be true
-
-				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)~)?")
-
-				expect(d.approximate?(:year)).to be true
-				expect(d.uncertain?(:year)).to be false
-
-				expect(d.approximate?(:month)).to be false
-				expect(d.uncertain?(:month)).to 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?~")
-
-				expect(d.approximate?(:year)).to be true
-				expect(d.uncertain?(:year)).to be false
-
-				expect(d.approximate?(:month)).to be false
-				expect(d.uncertain?(:month)).to 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)?")
-
-				expect(d.approximate?(:year)).to be true
-				expect(d.uncertain?(:year)).to be false
-
-				expect(d.approximate?(:month)).to be false
-				expect(d.uncertain?(:month)).to be true
-
-				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?")
-
-				expect(d.approximate?(:year)).to be true
-				expect(d.uncertain?(:year)).to be true
-
-				expect(d.approximate?(:month)).to be false
-				expect(d.uncertain?(:month)).to be true
-
-				expect(d.approximate?(:day)).to be false
-				expect(d.uncertain?(:day)).to be false
-
-			end
-
-
-
-    end
-  end
-end

data/spec/edtf/season_spec.rb

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

data/spec/edtf/set_spec.rb

@@ -1,107 +0,0 @@
-module EDTF
-  describe 'Sets' do
-
-    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
-
-    describe 'the set [1984,1985-10-01..]' do
-      let(:s1) { Set.new(Date.edtf('1984'), Date.edtf('1985-10-01')).later! }
-      let(:s2) { Date.edtf('[1984,1985-10-01..]') }
-
-      it 'has varying precision' do
-        expect(s1.map(&:precision)).to eq([:year, :day])
-        expect(s2.map(&:precision)).to eq([:year, :day])
-      end
-    end
-
-    describe 'the set [1760-12..1761-03]' do
-      let(:set) { Date.edtf('[1760-12..1761-03]') }
-      
-      it "is a choice" do
-        expect(set).to be_choice
-      end
-      
-      it "maps to the 4 months 1760-12 through 1761-03" do
-        expected_months = %w[1760-12 1761-01 1761-02 1761-03].map { |m| Date.edtf(m) }
-        expect(set.to_a).to eq(expected_months)
-      end
-    end
-
-    describe 'the set {1760-12..1761-03}' do
-      let(:set) { Date.edtf('{1760-12..1761-03}') }
-
-      it "is not a choice" do
-        expect(set).not_to be_choice
-      end
-
-      it "maps to the 4 months 1760-12 through 1761-03" do
-        expected_months = %w[1760-12 1761-01 1761-02 1761-03].map { |m| Date.edtf(m) }
-        expect(set.to_a).to eq(expected_months)
-      end
-    end
-  end
-end