edtf 3.3.0 → 4.0.0

data/spec/edtf/date_spec.rb

@@ -1,245 +0,0 @@
-describe 'Date/DateTime' do
-
-  describe 'class methods' do
-    it 'responds to edtf' do
-      expect(Date).to respond_to(:edtf)
-    end
-  end
-
-  describe 'instance methods' do
-    [:uncertain?, :approximate?, :unspecified?, :uncertain, :approximate, :unspecified].each do |method|
-      it "responds to #{method}" do
-        expect(Date.new.respond_to?(method)).to eq(true)
-      end
-    end
-  end
-
-  describe '#dup' do
-    let(:date) { Date.edtf('2004-09?~') }
-
-    it 'copies all date values' do
-      date.dup.to_s == '2004-09-01'
-    end
-
-    it 'copies uncertainty' do
-      expect(date.dup).to be_uncertain
-    end
-
-    it 'copies approximate' do
-      expect(date.dup).to be_approximate
-    end
-
-    it 'copies precision' do
-      expect(date.dup.precision).to eq(:month)
-    end
-
-    it 'copies uncertainty by value' do
-      expect { date.dup.certain! }.not_to change { date.uncertain? }
-    end
-
-  end
-
-	describe 'precisions' do
-		let(:date) { Date.today }
-
-		it 'has day precision by default' do
-			expect(date).to be_day_precision
-		end
-
-		it '#day_precison returns a new date object' do
-			expect(date.day_precision).not_to equal(date)
-			expect(date.day_precision).to eq(date)
-		end
-
-	end
-
-
-	describe '#negate' do
-    let(:date) { Date.edtf('2004?') }
-
-		it 'returns a new date with the negated year' do
-			expect(date.negate.year).to eq(date.year * -1)
-		end
-
-		it 'returns a new date with the same month' do
-			expect(date.negate.month).to eq(date.month)
-		end
-
-		it 'returns a new date with the same day' do
-			expect(date.negate.day).to eq(date.day)
-		end
-
-		it 'returns a new date with the same precision' do
-			expect(date.negate.precision).to eq(date.precision)
-		end
-	end
-
-	describe '#succ' do
-
-		it 'the successor of 2004 is 2005' do
-			expect(Date.edtf('2004').succ.year).to eq(2005)
-		end
-
-		it 'the successor of 2004-03 is 2004-04' do
-			expect(Date.edtf('2004-03').succ.strftime('%Y-%m')).to eq('2004-04')
-		end
-
-		it 'the successor of 2004-03-01 is 2004-03-02' do
-			expect(Date.edtf('2004-03-01').succ.strftime('%Y-%m-%d')).to eq('2004-03-02')
-		end
-
-		it "the successor of 1999 has year precision" do
-			expect(Date.edtf('1999').succ).to be_year_precision
-		end
-
-	end
-
-	describe '#next' do
-
-	  it 'returns the successor when given no argument' do
-			expect(Date.edtf('1999').next[0].year).to eq(2000)
-	  end
-
-	  it 'returns an array of the next 3 elements when passed 3 as an argument' do
-	    Date.edtf('1999').next(3).map(&:year) == [2000, 2001, 2002]
-	  end
-
-	end
-
-
-  describe '#change' do
-    let(:date) { Date.edtf('2004-09?~') }
-
-    it 'returns a copy of the date if given empty option hash' do
-      expect(date.change({})).to eq(date)
-		end
-
-    it 'the returned copy is not identical at object level' do
-      expect(date.change({})).not_to equal(date)
-    end
-
-    describe 'when given a new year' do
-      let(:changeset) { { :year => 1999 } }
-
-      it 'returns a new date instance with the changed year' do
-        expect(date.change(changeset).year).to eq(1999)
-      end
-
-    end
-
-    describe 'when given a new precision' do
-      let(:changeset) { { :precision => :year } }
-
-      it 'returns a new date instance with the changed precision' do
-        expect(date.change(changeset).precision).to eq(:year)
-      end
-
-    end
-
-    it 'copies extended values by value' do
-      expect { date.change({}).approximate! }.not_to change { date.approximate? }
-    end
-
-  end
-
-  describe '#uncertain?' do
-
-    let(:date) { Date.new }
-
-    it { expect(Date.new).not_to be_uncertain }
-
-    [:year, :month, :day].each do |part|
-      it "should not be uncertain by default (#{part})" do
-        expect(Date.new.uncertain?(part)).to eq(false)
-      end
-
-      it "should be uncertain if set to uncertain (#{part})" do
-        date.uncertain.send("#{part}=", true)
-        expect(date.uncertain?(part)).to eq(true)
-      end
-
-      ([:year, :month, :day] - [part]).each do |other|
-        it "#{other} should not be uncertain if #{part} is uncertain" do
-          date.uncertain.send("#{part}=", true)
-          expect(date.uncertain?(other)).to eq(false)
-        end
-      end
-
-    end
-
-  end
-
-  describe 'uncertain/approximate hash' do
-
-    it 'is 0 by default' do
-      expect(Date.new().send(:ua_hash)).to eq(0)
-    end
-
-    it 'is 8 for approximate year' do
-      expect(Date.new.approximate!(:year).send(:ua_hash)).to eq(8)
-    end
-
-  end
-
-	describe 'sorting and comparisons' do
-		let(:xmas) { Date.new(2011, 12, 24) }
-		let(:new_years_eve) { Date.new(2011, 12, 31) }
-
-		describe '#values' do
-
-			it 'returns [2011,12,24] for christmas' do
-				expect(xmas.values).to eq([2011,12,24])
-			end
-
-			it 'returns [2011,12] for christmas with month precision' do
-				expect(xmas.month_precision!.values).to eq([2011,12])
-			end
-
-			it 'returns [2011] for christmas with year precision' do
-				expect(xmas.year_precision!.values).to eq([2011])
-			end
-
-		end
-
-		describe '#<=>' do
-
-			it '2009-12-24 should be less than 2011-12-31' do
-				expect(Date.new(2009,12,24)).to be < Date.new(2011,12,31)
-			end
-
-			it '2009-12-24 should be less than 2011-12' do
-				expect(Date.new(2009,12,24)).to be < Date.edtf('2011-12')
-			end
-
-			it '2009-12-24 should be less than 2011' do
-				expect(Date.new(2009,12,24)).to be < Date.edtf('2011')
-			end
-
-
-		end
-
-		describe '#==' do
-
-			it "xmas and new year's eve are not equal" do
-				expect(xmas).not_to eq(new_years_eve)
-			end
-
-			it "xmas and new year's eve are equal using month percision" do
-				expect(xmas.month_precision!).to eq(new_years_eve.month_precision!)
-			end
-
-			it "xmas and january 24 are not equal using month percision" do
-				expect(xmas.month_precision!).not_to eq(xmas.month_precision!.next)
-			end
-
-
-			it "xmas and new year's eve are equal using year percision" do
-				expect(xmas.year_precision!).to eq(new_years_eve.year_precision!)
-			end
-
-		end
-
-	end
-
-
-end

data/spec/edtf/epoch_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-
-module EDTF
-	
-	describe Decade do
-		
-		it { is_expected.not_to be nil }
-
-		describe '.current' do
-			it 'creates the current decade' do
-				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
-				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
-				expect(Decade.new(1999).max).to eq(Date.new(1999).year_precision!)
-			end
-			
-			it 'has year precision' do
-				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
-				expect(Decade.new(1980)).to be_cover(Date.new(1989,12,31))
-			end
-		end
-		
-		describe '#to_range' do
-			
-			it 'returns a range' do
-				expect(Decade.new.to_range).to be_instance_of(::Range)
-			end
-			
-			it 'the range starts with a date object' do
-				expect(Decade.new.to_range.begin).to be_instance_of(::Date)
-			end
-
-			it 'the range ends with a date object' do
-				expect(Decade.new.to_range.end).to be_instance_of(::Date)
-			end
-
-			it 'the range start has year precision' do
-				expect(Decade.new.to_range.begin).to be_year_precision
-			end
-
-			it 'the range end has year precision' do
-				expect(Decade.new.to_range.end).to be_year_precision
-			end
-			
-		end
-		
-		describe 'enumeration' do
-			
-			it 'always covers ten years' do
-				expect(Decade.new.to_a.size).to eq(10)
-			end
-			
-			it 'the 1970s should map to the years [1970, 1971, ... , 1979]' do
-				expect(Decade.new(1970).map(&:year)).to eq([1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979])
-			end
-		
-		end
-		
-	end
-
-	describe Century do
-		
-		it { is_expected.not_to be nil }
-
-		describe '.current' do
-			it 'creates the current century' do
-				expect(Century.current.year).to eq((Time.now.year / 100) * 100)
-			end
-		end
-		
-	end
-	
-	
-end

data/spec/edtf/interval_spec.rb

@@ -1,308 +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-08-23/..' do
-      let(:interval) { Date.edtf('2008-08-23/..') }
-
-      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 open/2008-08-23' do
-      let(:interval) { Date.edtf('open/2008-08-23') }
-
-      it { expect(interval).to be_open }
-      it { expect(interval).to be_open_start }
-      it { expect(interval).not_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 max date is 2008-08-23' do
-        expect(interval.max).to eq(Date.new(2008,8,23))
-      end
-
-      it 'the min date is nil' do
-        expect(interval.min).to be nil
-      end
-
-      it 'includes christmas day 2007' do
-        expect(interval).to be_include(Date.new(2007,12,24))
-      end
-
-      it 'covers christmas day 2007' do
-        expect(interval).to be_cover(Date.new(2007,12,24))
-      end
-
-      it 'covers 2003-07-02' do
-        expect(interval).to be_cover(Date.new(2003,07,02))
-      end
-    end
-
-    describe 'the interval ../2008-08-23' do
-      let(:interval) { Date.edtf('../2008-08-23') }
-
-      it { expect(interval).to be_open }
-      it { expect(interval).to be_open_start }
-      it { expect(interval).not_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 max date is 2008-08-23' do
-        expect(interval.max).to eq(Date.new(2008,8,23))
-      end
-
-      it 'the min date is nil' do
-        expect(interval.min).to be nil
-      end
-
-      it 'includes christmas day 2007' do
-        expect(interval).to be_include(Date.new(2007,12,24))
-      end
-
-      it 'covers christmas day 2007' do
-        expect(interval).to be_cover(Date.new(2007,12,24))
-      end
-
-      it 'covers 2003-07-02' do
-        expect(interval).to be_cover(Date.new(2003,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 'the interval unknown/2008' do
-      let(:interval) { Date.edtf('unknown/2008') }
-
-      it { expect(interval).to be_unknown }
-      it { expect(interval).not_to be_unknown_end }
-      it { expect(interval).to be_unknown_start }
-
-      it 'the max date is 2008-12-31' do
-        expect(interval.max.to_s).to eq('2008-12-31')
-      end
-
-      it 'the max date has year precision' do
-        expect(interval.max).to be_year_precision
-      end
-
-      it 'the min date is nil' do
-        expect(interval.min).to be nil
-      end
-    end
-
-    describe 'the interval 2008/' do
-      let(:interval) { Date.edtf('2008/') }
-
-      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 'the interval /2008' do
-      let(:interval) { Date.edtf('/2008') }
-
-      it { expect(interval).to be_unknown }
-      it { expect(interval).not_to be_unknown_end }
-      it { expect(interval).to be_unknown_start }
-
-      it 'the max date is 2008-12-31' do
-        expect(interval.max.to_s).to eq('2008-12-31')
-      end
-
-      it 'the max date has year precision' do
-        expect(interval.max).to be_year_precision
-      end
-
-      it 'the min date is nil' do
-        expect(interval.min).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
-  end
-end