edtf 2.1.0 → 2.2.0

data/lib/edtf/parser.y

@@ -34,7 +34,8 @@ rule
 
 
   date_time : date T time {
-   result = DateTime.new(val[0].year, val[0].month, val[0].day, *val[2])
+    result = DateTime.new(val[0].year, val[0].month, val[0].day, *val[2])
+    result.skip_timezone = (val[2].length == 3)
   }
 
   time : base_time
@@ -53,8 +54,8 @@ rule
   positive_zone_offset : zone_offset_hour
                        | '0' '0' ':' '0' '0' { result = 0 }
                        ;
-           
-           
+
+
   zone_offset_hour : d01_13 ':' minute   { result = Rational(val[0] * 60 + val[2], 1440) }
                    | '1' '4' ':' '0' '0' { result = Rational(840, 1440) }
                    | '0' '0' ':' d01_59  { result = Rational(val[3], 1440) }
@@ -66,7 +67,7 @@ rule
 
   month : d01_12
   day : d01_31
-   
+
   year_month : year '-' month { result = [val[0], val[2]] }
 
   # We raise an exception if there are two many days for the month, but
@@ -134,7 +135,7 @@ rule
   }
 
   level_1_start : date | partial_uncertain_or_approximate | unspecified | partial_unspecified | UNKNOWN
-             
+
   level_1_end : level_1_start | OPEN
 
 
@@ -150,7 +151,7 @@ rule
       result.precision = :year
     }
     ;
-         
+
   long_year :
     positive_digit digit digit digit digit {
       result = val.zip([10000,1000,100,10,1]).reduce(0) { |s,(a,b)| s += a * b }
@@ -233,11 +234,11 @@ rule
        | list_elements                        { result = EDTF::Set.new(*val[0]) }
        | later                                { result = EDTF::Set.new(val[0]).later! }
        ;
-        
+
   list_elements : list_element                   { result = [val[0]].flatten }
                 | list_elements ',' list_element { result = val[0] + [val[2]].flatten }
                 ;
-     
+
   list_element : atomic
                | consecutives
                ;
@@ -289,18 +290,18 @@ rule
       result.unspecified!(:month)
     }
     ;
- 
+
 
   partial_uncertain_or_approximate : pua_base
     | '(' pua_base ')' UA { result = uoa(val[1], val[3]) }
-  
+
   pua_base :
     pua_year             { result = val[0].year_precision! }
     | pua_year_month     { result = val[0][0].month_precision! }
     | pua_year_month_day { result = val[0].day_precision! }
-  
+
   pua_year : year UA { result = uoa(Date.new(val[0]), val[1], :year) }
-  
+
   pua_year_month :
     pua_year '-' month ua {
       result = [uoa(val[0].change(:month => val[2]), val[3], [:month, :year])]
@@ -315,7 +316,7 @@ rule
         result = [uoa(val[0].change(:month => val[2]), val[4], [:month]), true]
     }
     ;
-  
+
   pua_year_month_day :
     pua_year_month '-' day ua {
       result = uoa(val[0][0].change(:day => val[2]), val[3], val[0][1] ? [:day] : nil)
@@ -355,7 +356,7 @@ rule
     #     result = [uoa(result, val[7], [:year]), true]
     # }
     ;
- 
+
   ua : { result = [] } | UA
 
   # ---- Auxiliary Rules ----
@@ -363,7 +364,7 @@ rule
   digit : '0' { result = 0 }
         | positive_digit
         ;
-    
+
   positive_digit : '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
 
   d01_12 : '0' positive_digit { result = val[1] }
@@ -375,7 +376,7 @@ rule
   d01_13 : d01_12
          | '1' '3'            { result = 13 }
          ;
-     
+
   d01_23 : '0' positive_digit { result = val[1] }
          | '1' digit          { result = 10 + val[1] }
          | '2' '0'            { result = 20 }
@@ -410,7 +411,7 @@ rule
          | '4' digit { result = 40 + val[1] }
          | '5' digit { result = 50 + val[1] }
          ;
-    
+
   d00_59 : '0' '0'
          | d01_59
          ;
@@ -442,32 +443,32 @@ require 'strscan'
     :level => 2,
     :debug => false
   }.freeze
-  
+
   class << self; attr_reader :defaults; end
-  
+
   attr_reader :options
-  
+
   def initialize(options = {})
     @options = Parser.defaults.merge(options)
   end
-  
+
   def debug?
     !!(options[:debug] || ENV['DEBUG'])
   end
-  
+
   def parse(input)
     parse!(input)
   rescue => e
     warn e.message if debug?
     nil
   end
-  
+
   def parse!(input)
     @yydebug = debug?
     @src = StringScanner.new(input)
     do_parse
   end
-  
+
   def on_error(tid, value, stack)
     raise ArgumentError,
       "failed to parse date: unexpected '#{value}' at #{stack.inspect}"
@@ -479,9 +480,9 @@ require 'strscan'
     end
     date
   end
-  
+
   alias uoa apply_uncertainty
-  
+
   def next_token
     case
     when @src.eos?
@@ -489,7 +490,7 @@ require 'strscan'
     # when @src.scan(/\s+/)
       # ignore whitespace
     when @src.scan(/\(/)
-      ['(', @src.matched] 
+      ['(', @src.matched]
     # when @src.scan(/\)\?~-/)
     #   [:PUA, [:uncertain!, :approximate!]]
     # when @src.scan(/\)\?-/)
@@ -552,4 +553,4 @@ require 'strscan'
   end
 
 
-# -*- racc -*-
+# -*- racc -*-

data/lib/edtf/set.rb

@@ -44,7 +44,9 @@ module EDTF
     end
 
     def edtf
-      parenthesize(dates.map { |d| d.respond_to?(:edtf) ? d.edtf : d.to_s }.sort.join(', '))
+      parenthesize(dates.map { |d|
+        d.respond_to?(:edtf) ? d.edtf : d.to_s
+      }.sort.join(','))
     end
 
     def to_a

data/lib/edtf/version.rb

@@ -1,3 +1,3 @@
 module EDTF
-  VERSION = '2.1.0'.freeze
+  VERSION = '2.2.0'.freeze
 end

data/spec/edtf/date_spec.rb

@@ -2,14 +2,14 @@ describe 'Date/DateTime' do
 
   describe 'class methods' do
     it 'responds to edtf' do
-      Date.should respond_to(:edtf)
+      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
-        Date.new.respond_to?(method).should == true
+        expect(Date.new.respond_to?(method)).to eq(true)
       end
     end
   end
@@ -22,19 +22,19 @@ describe 'Date/DateTime' do
     end
     
     it 'copies uncertainty' do
-      date.dup.should be_uncertain
+      expect(date.dup).to be_uncertain
     end
 
     it 'copies approximate' do
-      date.dup.should be_approximate
+      expect(date.dup).to be_approximate
     end
 
     it 'copies precision' do
-      date.dup.precision.should == :month
+      expect(date.dup.precision).to eq(:month)
     end
     
     it 'copies uncertainty by value' do
-      lambda { date.dup.certain! }.should_not change { date.uncertain? }
+      expect { date.dup.certain! }.not_to change { date.uncertain? }
     end
     
   end
@@ -43,12 +43,12 @@ describe 'Date/DateTime' do
 		let(:date) { Date.today }
 		
 		it 'has day precision by default' do
-			date.should be_day_precision
+			expect(date).to be_day_precision
 		end
 		
 		it '#day_precison returns a new date object' do
-			date.day_precision.should_not equal(date)
-			date.day_precision.should == date
+			expect(date.day_precision).not_to equal(date)
+			expect(date.day_precision).to eq(date)
 		end
 		
 	end
@@ -58,38 +58,38 @@ describe 'Date/DateTime' do
     let(:date) { Date.edtf('2004?') }
 		
 		it 'returns a new date with the negated year' do
-			date.negate.year.should == (date.year * -1)
+			expect(date.negate.year).to eq(date.year * -1)
 		end
 		
 		it 'returns a new date with the same month' do
-			date.negate.month.should == date.month
+			expect(date.negate.month).to eq(date.month)
 		end
 		
 		it 'returns a new date with the same day' do
-			date.negate.day.should == date.day
+			expect(date.negate.day).to eq(date.day)
 		end
 		
 		it 'returns a new date with the same precision' do
-			date.negate.precision.should == date.precision
+			expect(date.negate.precision).to eq(date.precision)
 		end
 	end
 	
 	describe '#succ' do
 		
 		it 'the successor of 2004 is 2005' do
-			Date.edtf('2004').succ.year.should == 2005
+			expect(Date.edtf('2004').succ.year).to eq(2005)
 		end
 
 		it 'the successor of 2004-03 is 2004-04' do
-			Date.edtf('2004-03').succ.strftime('%Y-%m').should == '2004-04'
+			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
-			Date.edtf('2004-03-01').succ.strftime('%Y-%m-%d').should == '2004-03-02'
+			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
-			Date.edtf('1999').succ.should be_year_precision
+			expect(Date.edtf('1999').succ).to be_year_precision
 		end
 
 	end
@@ -97,7 +97,7 @@ describe 'Date/DateTime' do
 	describe '#next' do
 	  
 	  it 'returns the successor when given no argument' do
-			Date.edtf('1999').next[0].year.should == 2000
+			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
@@ -111,18 +111,18 @@ describe 'Date/DateTime' do
     let(:date) { Date.edtf('2004-09?~') }
 
     it 'returns a copy of the date if given empty option hash' do
-      date.change({}).should == date
+      expect(date.change({})).to eq(date)
 		end
 		
     it 'the returned copy is not identical at object level' do
-      date.change({}).should_not equal(date)
+      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
-        date.change(changeset).year.should == 1999
+        expect(date.change(changeset).year).to eq(1999)
       end
       
     end
@@ -131,13 +131,13 @@ describe 'Date/DateTime' do
       let(:changeset) { { :precision => :year } }
       
       it 'returns a new date instance with the changed precision' do
-        date.change(changeset).precision.should == :year
+        expect(date.change(changeset).precision).to eq(:year)
       end
 
     end
 
     it 'copies extended values by value' do
-      lambda { date.change({}).approximate! }.should_not change { date.approximate? }
+      expect { date.change({}).approximate! }.not_to change { date.approximate? }
     end
     
   end
@@ -146,22 +146,22 @@ describe 'Date/DateTime' do
     
     let(:date) { Date.new }
     
-    it { Date.new.should_not be_uncertain }
+    it { expect(Date.new).not_to be_uncertain }
 
     [:year, :month, :day].each do |part|
       it "should not be uncertain by default (#{part})" do
-        Date.new.uncertain?(part).should == false
+        expect(Date.new.uncertain?(part)).to eq(false)
       end
 
       it "should be uncertain if set to uncertain (#{part})" do
         date.uncertain.send("#{part}=", true)
-        date.uncertain?(part).should == 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)
-          date.uncertain?(other).should == false
+          expect(date.uncertain?(other)).to eq(false)
         end
       end
       
@@ -172,11 +172,11 @@ describe 'Date/DateTime' do
   describe 'uncertain/approximate hash' do
     
     it 'is 0 by default' do
-      Date.new().send(:ua_hash).should == 0
+      expect(Date.new().send(:ua_hash)).to eq(0)
     end
     
     it 'is 8 for approximate year' do
-      Date.new.approximate!(:year).send(:ua_hash).should == 8
+      expect(Date.new.approximate!(:year).send(:ua_hash)).to eq(8)
     end
     
   end
@@ -188,15 +188,15 @@ describe 'Date/DateTime' do
 		describe '#values' do
 			
 			it 'returns [2011,12,24] for christmas' do
-				xmas.values.should == [2011,12,24]
+				expect(xmas.values).to eq([2011,12,24])
 			end
 
 			it 'returns [2011,12] for christmas with month precision' do
-				xmas.month_precision!.values.should == [2011,12]
+				expect(xmas.month_precision!.values).to eq([2011,12])
 			end
 
 			it 'returns [2011] for christmas with year precision' do
-				xmas.year_precision!.values.should == [2011]
+				expect(xmas.year_precision!.values).to eq([2011])
 			end
 			
 		end
@@ -204,15 +204,15 @@ describe 'Date/DateTime' do
 		describe '#<=>' do
 			
 			it '2009-12-24 should be less than 2011-12-31' do
-				Date.new(2009,12,24).should < Date.new(2011,12,31)
+				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
-				Date.new(2009,12,24).should < Date.edtf('2011-12')
+				expect(Date.new(2009,12,24)).to be < Date.edtf('2011-12')
 			end
 
 			it '2009-12-24 should be less than 2011' do
-				Date.new(2009,12,24).should < Date.edtf('2011')
+				expect(Date.new(2009,12,24)).to be < Date.edtf('2011')
 			end
 			
 			
@@ -221,20 +221,20 @@ describe 'Date/DateTime' do
 		describe '#==' do
 			
 			it "xmas and new year's eve are not equal" do
-				xmas.should_not == new_years_eve
+				expect(xmas).not_to eq(new_years_eve)
 			end
 
 			it "xmas and new year's eve are equal using month percision" do
-				xmas.month_precision!.should == new_years_eve.month_precision!
+				expect(xmas.month_precision!).to eq(new_years_eve.month_precision!)
 			end
 
 			it "xmas and january 24 are not equal using month percision" do
-				xmas.month_precision!.should_not == xmas.month_precision!.next
+				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
-				xmas.year_precision!.should == new_years_eve.year_precision!
+				expect(xmas.year_precision!).to eq(new_years_eve.year_precision!)
 			end
 			
 		end