edtf 0.0.2 → 0.0.3

data/lib/edtf/parser.y

@@ -4,6 +4,7 @@ class EDTF::Parser
 
 token T Z E X PLUS MINUS COLON SLASH D0 D1 D2 D3 D4 D5 D6 D7 D8 D9 LP RP
   UNCERTAIN APPROXIMATE UNSPECIFIED UNKNOWN OPEN LONGYEAR CARET UNMATCHED
+  DOTS COMMA LBRACE RBRACE LSQUARE RSQUARE
 
 expect 0
 
@@ -24,11 +25,11 @@ rule
   date : positive_date
        | negative_date
 
-  positive_date : year           { result = Date.new(val[0]) }
-                | year_month     { result = Date.new(*val.flatten) }
-                | year_month_day { result = Date.new(*val.flatten) }
+  positive_date : year           { result = Date.new(val[0]); result.precision = :year }
+                | year_month     { result = Date.new(*val.flatten); result.precision = :month }
+                | year_month_day { result = Date.new(*val.flatten); result.precision = :day }
                 
-  negative_date :  MINUS positive_date { result = Date.new(-1 * val[1].year, val[1].month, val[1].day) }
+  negative_date :  MINUS positive_date { result = -val[1] }
 
 
   date_time : date T time { result = DateTime.new(val[0].year, val[0].month, val[0].day, *val[2]) }
@@ -90,15 +91,15 @@ rule
                            | UNCERTAIN APPROXIMATE  { result = [:uncertain!, :approximate!] }
   
 
-  unspecified : unspecified_year
+  unspecified : unspecified_year          { result = Date.new(val[0][0]); result.unspecified.year[2,2] = val[0][1]; result.precision = :year }
               | unspecified_month
               | unspecified_day
               | unspecified_day_and_month
   
-  unspecified_year : digit digit digit UNSPECIFIED       { result = Date.new(val[0,3].zip([1000,100,10]).reduce(0) { |s,(a,b)| s += a * b }); result.unspecified.year[3] = true }
-                   | digit digit UNSPECIFIED UNSPECIFIED { result = Date.new(val[0,2].zip([1000,100]).reduce(0) { |s,(a,b)| s += a * b }); result.unspecified.year[2,2] = [true, true] }
+  unspecified_year : digit digit digit UNSPECIFIED       { result = [val[0,3].zip([1000,100,10]).reduce(0) { |s,(a,b)| s += a * b }, [false,true]] }
+                   | digit digit UNSPECIFIED UNSPECIFIED { result = [val[0,2].zip([1000,100]).reduce(0) { |s,(a,b)| s += a * b }, [true, true]] }
   
-  unspecified_month : year MINUS UNSPECIFIED UNSPECIFIED { result = Date.new(val[0]).unspecified!(:month) }
+  unspecified_month : year MINUS UNSPECIFIED UNSPECIFIED { result = Date.new(val[0]).unspecified!(:month); result.precision = :month }
   
   unspecified_day : year_month MINUS UNSPECIFIED UNSPECIFIED { result = Date.new(*val[0]).unspecified!(:day) }
   
@@ -115,14 +116,14 @@ rule
               | OPEN                             { result = :open }
 
 
-  long_year_simple : LONGYEAR long_year          { result = Date.new(val[1]) }
-                   | LONGYEAR MINUS long_year    { result = Date.new(-1 * val[2]) }
+  long_year_simple : LONGYEAR long_year          { result = Date.new(val[1]); result.precision = :year }
+                   | LONGYEAR MINUS long_year    { result = Date.new(-1 * val[2]); 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 } }
             | long_year digit { result = 10 * val[0] + val[1] }
 
 
-  season : year MINUS season_number { result = Date.new(val[0]); result.season = val[2] }
+  season : year MINUS season_number { result = Date.new(val[0]); result.season = val[2]; result.precision = :year }
 
   season_number : D2 D1 { result = 21 }
                 | D2 D2 { result = 22 }
@@ -134,9 +135,9 @@ rule
   
   level_2_expression : season_qualified
                      # | internal_uncertain_or_approximate
-                     # | internal_unspecified
-                     # | choice_list
-                     # | inclusive_list
+                     | internal_unspecified
+                     | choice_list
+                     | inclusive_list
                      | masked_precision
                      # | level_2_interval
                      | date_and_calendar
@@ -146,9 +147,9 @@ rule
   season_qualified : season CARET { result = val[0]; result.qualifier = val[1] }
 
 
-  long_year_scientific : long_year_simple E integer      { result = Date.new(val[0].year * 10 ** val[2]) }
-                       | LONGYEAR int1_4 E integer       { result = Date.new(val[1] * 10 ** val[3]) }
-                       | LONGYEAR MINUS int1_4 E integer { result = Date.new(-1 * val[2] * 10 ** val[4]) }
+  long_year_scientific : long_year_simple E integer      { result = Date.new(val[0].year * 10 ** val[2]); result.precision = :year }
+                       | LONGYEAR int1_4 E integer       { result = Date.new(val[1] * 10 ** val[3]); result.precision = :year }
+                       | LONGYEAR MINUS int1_4 E integer { result = Date.new(-1 * val[2] * 10 ** val[4]); result.precision = :year }
   
 
   date_and_calendar : date CARET { result = val[0]; result.calendar = val[1] }
@@ -157,6 +158,46 @@ rule
   masked_precision : digit digit digit X { d = val[0,3].zip([1000,100,10]).reduce(0) { |s,(a,b)| s += a * b }; result = Date.new(d) ... Date.new(d+10) }
                    | digit digit X X     { d = val[0,2].zip([1000,100]).reduce(0) { |s,(a,b)| s += a * b }; result = Date.new(d) ... Date.new(d+100) }
 
+  
+  choice_list : LSQUARE list RSQUARE { result = val[1] }
+  
+  inclusive_list : LBRACE list RBRACE { result = val[1] }
+  
+  list : earlier                                 { result = [val[0]] }
+       | earlier COMMA list_elements COMMA later { result = [val[0]] + val[2] + [val[4]] }
+       | earlier COMMA list_elements             { result = [val[0]] + val[2] }
+       | earlier COMMA later                     { result = [val[0]] + [val[2]] }
+       | list_elements COMMA later               { result = val[0] + [val[2]] }
+       | list_elements
+       | later                                   { result = [val[0]] }
+           
+  list_elements : list_element                     { result = [val[0]].flatten }
+                | list_elements COMMA list_element { result = val[0] + [val[2]].flatten }
+                
+  list_element : date
+               # | date_with_internal_uncertainty
+               | uncertain_or_approximate_date
+               | unspecified
+               | consecutives                      { result = val[0].map { |d| Date.new(*d) } }
+  
+  earlier : DOTS date          { result = val[1] }
+  
+  later : year_month_day DOTS  { result = Date.new(*val[0]); result.precision = :day }
+        | year_month DOTS      { result = Date.new(*val[0]); result.precision = :month }
+        | year DOTS            { result = Date.new(val[0]); result.precision = :year }
+  
+  consecutives : year_month_day DOTS year_month_day
+               | year_month DOTS year_month
+               | year DOTS year                      { result = (val[0]..val[2]).to_a.map }
+
+  
+  internal_unspecified : unspecified_year MINUS month MINUS d01_31 { result = Date.new(val[0][0], val[2], val[4]); result.unspecified.year[2,2] = val[0][1] }
+   | unspecified_year MINUS UNSPECIFIED UNSPECIFIED MINUS d01_31  { result = Date.new(val[0][0], 1, val[5]); result.unspecified.year[2,2] = val[0][1]; result.unspecified!(:month) }
+   | unspecified_year MINUS UNSPECIFIED UNSPECIFIED MINUS UNSPECIFIED UNSPECIFIED { result = Date.new(val[0][0], 1, 1); result.unspecified.year[2,2] = val[0][1]; result.unspecified!([:month, :day]) }
+   | unspecified_year MINUS month MINUS UNSPECIFIED UNSPECIFIED  { result = Date.new(val[0][0], val[2], 1); result.unspecified.year[2,2] = val[0][1]; result.unspecified!(:day) }
+   | year MINUS UNSPECIFIED UNSPECIFIED MINUS d01_31  { result = Date.new(val[0], 1, val[5]); result.unspecified!(:month) }
+  
+
   # ---- Auxiliary Rules ----
 
   digit : D0             { result = 0 }
@@ -265,10 +306,20 @@ require 'strscan'
   def tokenize
     until @src.eos?
       case
+      # when @src.scan(/\s+/)
+        # ignore whitespace
       when @src.scan(/\(/)
         @stack << [:LP, @src.matched]
       when @src.scan(/\)/)
         @stack << [:RP, @src.matched]
+      when @src.scan(/\[/)
+        @stack << [:LSQUARE, @src.matched]
+      when @src.scan(/\]/)
+        @stack << [:RSQUARE, @src.matched]
+      when @src.scan(/\{/)
+        @stack << [:LBRACE, @src.matched]
+      when @src.scan(/\}/)
+        @stack << [:RBRACE, @src.matched]
       when @src.scan(/T/)
         @stack << [:T, @src.matched]
       when @src.scan(/Z/)
@@ -297,6 +348,10 @@ require 'strscan'
         @stack << [:COLON, @src.matched]
       when @src.scan(/\//)
         @stack << [:SLASH, @src.matched]
+      when @src.scan(/\s*\.\.\s*/)
+        @stack << [:DOTS, '..']
+      when @src.scan(/\s*,\s*/)
+        @stack << [:COMMA, ',']
       when @src.scan(/\^\w+/)
         @stack << [:CARET, @src.matched[1..-1]]
       when @src.scan(/\d/)

data/lib/edtf/version.rb

@@ -1,3 +1,3 @@
 module EDTF
-  VERSION = '0.0.2'.freeze
+  VERSION = '0.0.3'.freeze
 end

data/lib/edtf.rb

@@ -39,6 +39,7 @@ require 'edtf/version'
 require 'edtf/uncertainty'
 require 'edtf/seasons'
 require 'edtf/date'
+require 'edtf/date_time'
 require 'edtf/interval'
 require 'edtf/parser'
 require 'edtf/extensions'

data/spec/edtf/parser_spec.rb

@@ -0,0 +1,171 @@
+module EDTF
+  describe Parser do
+    describe '#parse' do
+      
+      it 'parses simple dates' do
+        Parser.new.parse('2001-02-03').to_s.should == '2001-02-03'
+      end
+      
+      it 'parses negative years' do
+        Parser.new.parse('-2323').to_s.should == '-2323-01-01'
+      end
+      
+      it 'parses year zero' do
+        Parser.new.parse('0000').to_s.should == '0000-01-01'
+      end
+      
+      it 'parses date/time with time zones' do
+        Parser.new.parse('2011-08-15T11:19:00+01:00').to_s.should == '2011-08-15T11:19:00+01:00'
+      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_not include(Date.new(2008,1,2))
+      end
+   
+      it 'parses uncertain dates' do
+        Parser.new.parse('1984?').should be_uncertain
+        Parser.new.parse('1984').should be_certain
+      end
+
+      it 'parses approximate dates' do
+        Parser.new.parse('1984-01~').should be_approximate
+        Parser.new.parse('1984-01').should be_precise
+      end
+
+      it 'parses uncertain approximate dates' do
+        Parser.new.parse('1984?~').should be_uncertain
+        Parser.new.parse('1984?~').should be_approximate
+      end
+
+      it 'parses unspecified dates' do
+        Parser.new.parse('199u').should be_unspecified
+        Parser.new.parse('1999-uu-uu').should be_unspecified
+      end
+      
+      it 'parses open intervals' do
+        Parser.new.parse('2004-01-01/open').should be_open
+      end
+
+      it 'parses unknown intervals' do
+        Parser.new.parse('2004-01-01/unknown').should be_unknown_end
+        Parser.new.parse('unknown/2004-01-01').should be_unknown_start
+      end
+      
+      it 'parses intervals with uncertain or approximate dates' do
+        Parser.new.parse('1984-06-02?/2004-08-08~').from.should be_uncertain
+        Parser.new.parse('1984-06-02?/2004-08-08~').to.should be_approximate
+      end
+      
+      it 'should parse positive long years' do
+        Parser.new.parse('y170000002').year.should == 170000002
+      end
+      
+      it 'should parse negative long years' do
+        Parser.new.parse('y-170000002').year.should == -170000002
+      end
+      
+      it 'should parse season codes' do
+        Parser.new.parse('2003-23').should be_autumn
+      end
+
+      it 'should parse calendar names' do
+        Parser.new.parse('2001-02-03^xyz').calendar.should == 'xyz'
+      end
+      
+      it 'should parse 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
+        Parser.new.parse('y17e7').year.should == 170000000
+      end
+      
+      it 'should parse 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.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.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.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.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.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.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.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.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'
+      end
+      
+      it 'parses intern unspecified "19uu-01-01"' do
+        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'
+      end
+      
+      it 'parses intern unspecified "19uu-uu-01"' do
+        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'
+      end
+      
+      it 'parses intern unspecified "19uu-uu-uu"' do
+        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'
+      end
+      
+      it 'parses intern unspecified "19uu-01-uu"' do
+        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'
+      end
+      
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: edtf
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2011-08-15 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &2157415200 !ruby/object:Gem::Requirement
+  requirement: &2157012300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '0.9'
   type: :development
   prerelease: false
-  version_requirements: *2157415200
+  version_requirements: *2157012300
 - !ruby/object:Gem::Dependency
   name: racc
-  requirement: &2157414020 !ruby/object:Gem::Requirement
+  requirement: &2156999280 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: '1.4'
   type: :development
   prerelease: false
-  version_requirements: *2157414020
+  version_requirements: *2156999280
 - !ruby/object:Gem::Dependency
   name: cucumber
-  requirement: &2157413420 !ruby/object:Gem::Requirement
+  requirement: &2156998780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: '1.0'
   type: :development
   prerelease: false
-  version_requirements: *2157413420
+  version_requirements: *2156998780
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2157412820 !ruby/object:Gem::Requirement
+  requirement: &2156998280 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: '2.6'
   type: :development
   prerelease: false
-  version_requirements: *2157412820
+  version_requirements: *2156998280
 - !ruby/object:Gem::Dependency
   name: ZenTest
-  requirement: &2157412220 !ruby/object:Gem::Requirement
+  requirement: &2156997760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,7 +65,7 @@ dependencies:
         version: '4.6'
   type: :development
   prerelease: false
-  version_requirements: *2157412220
+  version_requirements: *2156997760
 description: An Extended Date/Time Format (EDTF) Parser for Ruby.
 email:
 - http://sylvester.keil.or.at
@@ -75,6 +75,7 @@ extra_rdoc_files:
 - README.md
 - LICENSE
 files:
+- .autotest
 - .gitignore
 - .rspec
 - Gemfile
@@ -92,13 +93,14 @@ files:
 - lib/edtf.rb
 - lib/edtf/compatibility.rb
 - lib/edtf/date.rb
+- lib/edtf/date_time.rb
 - lib/edtf/extensions.rb
 - lib/edtf/interval.rb
 - lib/edtf/parser.y
 - lib/edtf/seasons.rb
 - lib/edtf/uncertainty.rb
 - lib/edtf/version.rb
-- spec/edtf/extensions_spec.rb
+- spec/edtf/parser_spec.rb
 - spec/edtf/seasons_spec.rb
 - spec/edtf/uncertainty_spec.rb
 - spec/spec_helper.rb
@@ -143,7 +145,7 @@ test_files:
 - features/parser/unspecified.feature
 - features/step_definitions/edtf_steps.rb
 - features/support/env.rb
-- spec/edtf/extensions_spec.rb
+- spec/edtf/parser_spec.rb
 - spec/edtf/seasons_spec.rb
 - spec/edtf/uncertainty_spec.rb
 - spec/spec_helper.rb

data/spec/edtf/extensions_spec.rb

@@ -1,44 +0,0 @@
-describe DateTime do
-
-  let(:date) { DateTime.new }
-
-  describe 'class methods' do
-    it 'responds to edtf' do
-      DateTime.respond_to?(:edtf).should == true
-    end
-  end
-  
-  describe 'instance methods' do
-    [:uncertain?, :approximate?, :unspecified?, :uncertain, :approximate, :unspecified].each do |method|
-      it "responds to #{method}" do
-        DateTime.new.respond_to?(method).should == true
-      end
-    end
-  end
-  
-  describe '#uncertain?' do
-    
-    it { should_not be_uncertain }
-
-    [:year, :month, :day].each do |part|
-      it "should not be uncertain by default (#{part})" do
-        DateTime.new.uncertain?(part).should == false
-      end
-
-      it "should be uncertain if set to uncertain (#{part})" do
-        date.uncertain.send("#{part}=", true)
-        date.uncertain?(part).should == 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
-        end
-      end
-      
-    end
-    
-  end
-    
-end