edtf 3.2.0 → 4.0.0

data/spec/edtf/interval_spec.rb

@@ -1,161 +0,0 @@
-module EDTF
-  describe 'Interval' do
-
-    describe 'the interval 2008/2011' do
-      let(:interval) { Date.edtf('2008/2011') }
-
-			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
-        expect(interval.to_a.length).to eq(4)
-      end
-
-      it '#step(2) yields the years 2008 and 2010' do
-        expect(interval.step(2).map(&:year)).to eq([2008,2010])
-      end
-
-      it 'the max date is 2011-12-31' do
-        expect(interval.max.to_s).to eq('2011-12-31')
-      end
-
-      it 'the max date has year precision' do
-        expect(interval.max).to be_year_precision
-      end
-
-      it 'the min date is 2008-01-01' do
-        expect(interval.min.to_s).to eq('2008-01-01')
-      end
-
-      it 'the min date has year precision' do
-        expect(interval.min).to be_year_precision
-      end
-
-
-      it 'includes the years 2008, 2009, 2010 and 2011' do
-        expect(interval.to_a.map(&:year)).to eq([2008, 2009, 2010, 2011])
-      end
-
-      it 'does not include christmas day 2009' do
-        expect(interval).not_to be_include(Date.new(2009,12,24))
-      end
-
-      it 'christmas day 2009 is less than max' do
-        expect(Date.new(2009,12,24)).to be < interval.max
-      end
-
-      it 'christmas day 2009 is greater than min' do
-        expect(Date.new(2009,12,24)).to be > interval.min
-      end
-
-      it 'covers christmas day 2009' do
-        expect(interval).to be_cover(Date.new(2009,12,24))
-      end
-
-      it 'covers 2011-12-31' do
-        expect(interval).to be_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
-        expect(interval).to be_include(Date.new(2009,12,24))
-      end
-
-      it 'covers christmas day 2009' do
-        expect(interval).to be_cover(Date.new(2009,12,24))
-      end
-
-      it 'does not cover 2011-07-02' do
-        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 { 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
-        expect(interval.min).to eq(Date.new(2008,8,23))
-      end
-
-      it 'the max date is nil' do
-        expect(interval.max).to be nil
-      end
-
-      it 'includes christmas day 2009' do
-        expect(interval).to be_include(Date.new(2009,12,24))
-      end
-
-      it 'covers christmas day 2009' do
-        expect(interval).to be_cover(Date.new(2009,12,24))
-      end
-
-      it 'covers 2023-07-02' do
-        expect(interval).to be_cover(Date.new(2023,07,02))
-      end
-
-    end
-
-    describe 'the interval 2008/unknown' do
-      let(:interval) { Date.edtf('2008/unknown') }
-
-      it { expect(interval).to be_unknown }
-      it { expect(interval).to be_unknown_end }
-      it { expect(interval).not_to be_unknown_start }
-
-      it 'the min date is 2008-01-01' do
-        expect(interval.min.to_s).to eq('2008-01-01')
-      end
-
-      it 'the min date has year precision' do
-        expect(interval.min).to be_year_precision
-      end
-
-      it 'the max date is nil' do
-        expect(interval.max).to be nil
-      end
-    end
-
-    describe 'comparisions' do
-      it '2007/2009 should be greater than 2001/2002' do
-        expect(Date.edtf('2007/2009')).to be > Date.edtf('2001/2002')
-      end
-
-      it '2007/2009 should be less than 2011/2012' do
-        expect(Date.edtf('2007/2009')).to be < Date.edtf('2011/2012')
-      end
-
-      it '2007/2009 should be less than 2008/2009' do
-        expect(Date.edtf('2007/2009')).to be < Date.edtf('2008/2009')
-      end
-
-      it '2007/2009 should be greater than 2007/2008' do
-        expect(Date.edtf('2007/2009')).to be > Date.edtf('2007/2008')
-      end
-
-      it '2007/2009 should be greater than 2006/2007' do
-        expect(Date.edtf('2007/2009')).to be > Date.edtf('2006/2007')
-      end
-
-      it '2007/2009 should be equal to 2007/2009' do
-        expect(Date.edtf('2007/2009')).to eq(Date.edtf('2007/2009'))
-      end
-    end
-
-    it 'may not have an open start' do
-      expect {
-        Interval.new(:open, Date.today)
-      }.to raise_error(ArgumentError)
-    end
-  end
-end

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