edtf 0.0.5 → 0.0.6

data/README.md

@@ -8,20 +8,15 @@ Specification](http://www.loc.gov/standards/datetime/spec.html).
 Compatibility
 -------------
 
-As of EDTF Specification DRAFT, August 4, 2001:
-
-* Level 0: fully implemented
-* Level 1: fully implemented
-* Level 2: implemented features 202, 203, 204, 2041, 207, 208, and 209
+EDTF-Ruby parser fully implements all levels and features of EDTF
+Specification DRAFT, August 4, 2011.
 
 The level 2 list extensions (203 and 204) currently return simple Ruby arrays;
 therefore, advanced behavior (such as 'earlier' or 'later') is parsed correctly
 but not yet exposed by the Ruby API.
 
-The level 2 extensions 201 and 205 are currently _not_ supported.
-
 EDTF-Ruby has been confirmed to work on the following Ruby implementations:
-1.9.2, 1.8.7, rbx, jruby.
+1.9.2, 1.8.7, Rubinius, and JRuby.
 
 
 Quickstart
@@ -37,33 +32,35 @@ given a valid EDTF string the return value will either be an (extended) `Date`,
     > require 'edtf'
     > d = Date.edtf('1984?')
     > d.uncertain?
-     => true
+    => true
     > d.certain!
     > d.uncertain?               
-     => false
+    => false
     > d = Date.edtf('1999-03-uu')
     > d.unspecified?
-     => true
+    => true
     > d.unspecified? :year
-     => false
+    => false
     > d.unspecified? :day
-     => true
+    => true
     > Date.edtf('2003-24').winter?
-     => true
+    => true
     > Date.edtf('196x')
-     => #<Date: 1960-01-01>...#<Date: 1970-01-01>
+    => #<Date: 1960-01-01>...#<Date: 1970-01-01>
     > Date.edtf('y-17e7').year
-     => -170000000
+    => -170000000
     > d = Date.edtf('1984-06?/2004-08?')
     > d.from.uncertain?
-     => true
-    > d.each.to_a.length
-     => 7367 # days between 1984-06 and 2004-08
-    > Date.edtf('2004-01-01/open').open?
-     => true
+    => true
+    > d.to_a.length
+    => 7397 # days between 1984-06-01 and 2004-08-31
+    > Date.edtf('1582-10/1582-10').to_a.length
+    => 21 # number of days in October 1582 (Gregorian calendar)
+    > Date.edtf('2004/open').open?
+    => true
     
 
-For additional features take a look at the rdoc, source, and rspec examples.
+For additional features take a look at the RDoc and RSpec examples.
 
 
 Development
@@ -72,16 +69,18 @@ Development
     $ git clone https://inukshuk@github.com/inukshuk/edtf-ruby.git
     $ cd edtf-ruby
     $ bundle install
-    $ bundle exec rake racc
+    $ bundle exec rake racc_debug
     $ bundle exec rspec spec
     $ bundle exec cucumber
 
-For extra credit, fork the project on github: pull requests welcome!
+For extra credit, fork the project on GitHub: pull requests welcome!
+
 
 Credits
 -------
 
-EDTF-Ruby was written by [Sylvester Keil](http://sylvester.keil.or.at).
+EDTF-Ruby was written by [Sylvester Keil](http://sylvester.keil.or.at) and
+[Namyra](https://github.com/namyra).
 
 Published under the terms and conditions of the FreeBSD License; see LICENSE
 for details.

data/features/parser/dates.feature

@@ -31,11 +31,11 @@ Feature: EDTF parser parses date strings
 
     @101 @level1
     Scenarios: uncertain date examples from the specification
-      | string      | year | uncertain-year | month | uncertain-month | day | uncertain-day |
-      | 1992?       | 1992 | yes            | 1     | yes             | 1   | yes           |
-      | 1984?       | 1984 | yes            | 1     | yes             | 1   | yes           |
-      | 2004-06?    | 2004 | yes            | 6     | yes             | 1   | yes           |
-      | 2004-06-11? | 2004 | yes            | 6     | yes             | 11  | yes           |
+     | string      | year | uncertain-year | month | uncertain-month | day | uncertain-day |
+     | 1992?       | 1992 | yes            | 1     | no              | 1   | no            |
+     | 1984?       | 1984 | yes            | 1     | no              | 1   | no            |
+     | 2004-06?    | 2004 | yes            | 6     | yes             | 1   | no            |
+     | 2004-06-11? | 2004 | yes            | 6     | yes             | 11  | yes           |
 
 
   Scenario Outline: EDTF parses uncertain or approximate date strings
@@ -51,3 +51,26 @@ Feature: EDTF parser parses date strings
       | string      | year | month | day | uncertain | approximate |
       | 1984~       | 1984 | 1     | 1   | no        | yes         |
       | 1984?~      | 1984 | 1     | 1   | yes       | yes         |
+
+  Scenario Outline: EDTF parses uncertain or approximate dates
+    When I parse the string "<string>"
+    And the year should be uncertain? "<?-year>"
+    And the month should be uncertain? "<?-month>"
+    And the day should be uncertain? "<?-day>"
+    And the year should be approximate? "<~-year>"
+    And the month should be approximate? "<~-month>"
+    And the day should be approximate? "<~-day>"
+
+  @201 @level2
+  Scenarios: uncertain date examples from the specification
+   | string          | ~-year | ?-year | ~-month | ?-month | ~-day | ?-day |
+	 | 2004?-06-11     | no     | yes    | no      | no      | no    | no    |
+	 | 2004-06~-11     | yes    | no     | yes     | no      | no    | no    |
+	 | 2004-(06)?-11   | no     | no     | no      | yes     | no    | no    |
+	 | 2004-06-(11)~   | no     | no     | no      | no      | yes   | no    |
+	 | 2004-(06)?~     | no     | no     | yes     | yes     | no    | no    |
+	 | 2004-(06-11)?   | no     | no     | no      | yes     | no    | yes   |
+	 | 2004?-06-(11)~  | no     | yes    | no      | no      | yes   | no    |
+	 | (2004-(06)~)?   | no     | yes    | yes     | yes     | no    | no    |
+	 | 2004-06-(01)~   | no     | no     | no      | no      | yes   | no    |
+

data/features/print/level_0_edtf.feature

@@ -0,0 +1,73 @@
+Feature: Print Date/Time objects as Level 1 EDTF strings
+  As a Ruby programmer
+  I want to convert Date/Time objects to EDTF strings
+  
+  @001 @level0
+  Scenario: Convert simple dates
+    Given the date "2004-08-12"
+    When I convert the date
+    Then the EDTF string should be "2004-08-12"
+
+	@001 @level0
+	Scenario: Convert simple dates with precision
+		Given the date "1980-08-24" with precision set to "day"
+		When I convert the date
+		Then the EDTF string should be "1980-08-24"
+		Given the date "1980-08-24" with precision set to "month"
+		When I convert the date
+		Then the EDTF string should be "1980-08"
+		Given the date "1980-08-24" with precision set to "year"
+		When I convert the date
+		Then the EDTF string should be "1980"
+
+	@001 @level0
+	Scenario: Date Roundtrips
+		When I parse the string "2001-02-03"
+		When I convert the date
+		Then the EDTF string should be "2001-02-03"
+		When I parse the string "2001-02"
+		When I convert the date
+		Then the EDTF string should be "2001-02"
+		When I parse the string "2001"
+		When I convert the date
+		Then the EDTF string should be "2001"
+		When I parse the string "-9909"
+		When I convert the date
+		Then the EDTF string should be "-9909"
+		When I parse the string "0000"
+		When I convert the date
+		Then the EDTF string should be "0000"
+
+	@002 @level0
+	Scenario: DateTime Roundtrips
+		When I parse the string "2001-02-03T09:30:01"
+		When I convert the date
+		Then the EDTF string should be "2001-02-03T09:30:01+00:00"
+		When I parse the string "2004-01-01T10:10:10Z"
+		When I convert the date
+		Then the EDTF string should be "2004-01-01T10:10:10+00:00"
+		When I parse the string "2004-01-01T10:10:10+05:00"
+		When I convert the date
+		Then the EDTF string should be "2004-01-01T10:10:10+05:00"
+
+	@004 @level0
+	Scenario: Interval Roundtrips
+		When I parse the string "1964/2008"
+		When I convert the date
+		Then the EDTF string should be "1964/2008"
+		When I parse the string "2004-06/2006-08"
+		When I convert the date
+		Then the EDTF string should be "2004-06/2006-08"
+		When I parse the string "2004-02-01/2005-02-08"
+		When I convert the date
+		Then the EDTF string should be "2004-02-01/2005-02-08"
+		When I parse the string "2004-02-01/2005-02"
+		When I convert the date
+		Then the EDTF string should be "2004-02-01/2005-02"
+		When I parse the string "2004-02-01/2005"
+		When I convert the date
+		Then the EDTF string should be "2004-02-01/2005"		
+		When I parse the string "2005/2006-02"
+		When I convert the date
+		Then the EDTF string should be "2005/2006-02"
+		

data/features/print/level_1_edtf.feature

@@ -1,68 +1,15 @@
-Feature: Print Date/Time objects as Level 1 EDTF strings
+Feature: Print Date/Time objects as Level 2 EDTF strings
   As a Ruby programmer
   I want to convert Date/Time objects to EDTF strings
   
-  Scenario: Convert simple dates
-    Given the date "2004-08-12"
-    When I convert the date
-    Then the EDTF string should be "2004-08-12"
-
-	Scenario: Convert simple dates with precision
-		Given the date "1980-08-24" with precision set to "day"
+  @101 @level1
+	Scenario: Uncertain or approximate dates
+		When I parse the string "2001?"
 		When I convert the date
-		Then the EDTF string should be "1980-08-24"
-		Given the date "1980-08-24" with precision set to "month"
+		Then the EDTF string should be "2001?"
+		When I parse the string "2004-06?"
 		When I convert the date
-		Then the EDTF string should be "1980-08"
-		Given the date "1980-08-24" with precision set to "year"
+		Then the EDTF string should be "2004-06?"
+		When I parse the string "2004-06-11?"
 		When I convert the date
-		Then the EDTF string should be "1980"
-
-	Scenario: Date Roundtrips
-		When I parse the string "2001-02-03"
-		When I convert the date
-		Then the EDTF string should be "2001-02-03"
-		When I parse the string "2001-02"
-		When I convert the date
-		Then the EDTF string should be "2001-02"
-		When I parse the string "2001"
-		When I convert the date
-		Then the EDTF string should be "2001"
-		When I parse the string "-9909"
-		When I convert the date
-		Then the EDTF string should be "-9909"
-		When I parse the string "0000"
-		When I convert the date
-		Then the EDTF string should be "0000"
-
-	Scenario: DateTime Roundtrips
-		When I parse the string "2001-02-03T09:30:01"
-		When I convert the date
-		Then the EDTF string should be "2001-02-03T09:30:01+00:00"
-		When I parse the string "2004-01-01T10:10:10Z"
-		When I convert the date
-		Then the EDTF string should be "2004-01-01T10:10:10+00:00"
-		When I parse the string "2004-01-01T10:10:10+05:00"
-		When I convert the date
-		Then the EDTF string should be "2004-01-01T10:10:10+05:00"
-
-	Scenario: Interval Roundtrips
-		When I parse the string "1964/2008"
-		When I convert the date
-		Then the EDTF string should be "1964/2008"
-		When I parse the string "2004-06/2006-08"
-		When I convert the date
-		Then the EDTF string should be "2004-06/2006-08"
-		When I parse the string "2004-02-01/2005-02-08"
-		When I convert the date
-		Then the EDTF string should be "2004-02-01/2005-02-08"
-		When I parse the string "2004-02-01/2005-02"
-		When I convert the date
-		Then the EDTF string should be "2004-02-01/2005-02"
-		When I parse the string "2004-02-01/2005"
-		When I convert the date
-		Then the EDTF string should be "2004-02-01/2005"		
-		When I parse the string "2005/2006-02"
-		When I convert the date
-		Then the EDTF string should be "2005/2006-02"
-		
+		Then the EDTF string should be "2004-06-11?"

data/features/step_definitions/edtf_steps.rb

@@ -93,6 +93,19 @@ Then /^the date should be approximate\? "([^"]*)"$/ do |arg1|
   @date.approximate?.should == !!(arg1 =~ /y(es)?/i)
 end
 
+Then /^the year should be approximate\? "([^"]*)"$/ do |arg1|
+  @date.approximate?(:year).should == !!(arg1 =~ /y(es)?/i)
+end
+
+Then /^the month should be approximate\? "([^"]*)"$/ do |arg1|
+  @date.approximate?(:month).should == !!(arg1 =~ /y(es)?/i)
+end
+
+Then /^the day should be approximate\? "([^"]*)"$/ do |arg1|
+  @date.approximate?(:day).should == !!(arg1 =~ /y(es)?/i)
+end
+
+
 Then /^the unspecified string code be "([^"]*)"$/ do |arg1|
   @date.unspecified.to_s.should == arg1
 end

data/lib/edtf/date.rb

@@ -46,6 +46,7 @@ class Date
     @precision ||= :day
   end
   
+	# Sets this Date/Time's precision to the passed-in value.
   def precision=(precision)
     precision = precision.to_sym
     raise ArgumentError, "invalid precision #{precision.inspect}" unless PRECISIONS.include?(precision)
@@ -71,37 +72,37 @@ class Date
   
   def_delegators :uncertain, :uncertain?, :certain?
 
-  def certain!(*arguments)
-    uncertain.certain!(*arguments)
+  def certain!(arguments = precision_filter)
+    uncertain.certain!(arguments)
     self
   end
   
-  def uncertain!(*arguments)
-    uncertain.uncertain!(*arguments)
+  def uncertain!(arguments = precision_filter)
+    uncertain.uncertain!(arguments)
     self
   end
 
-  def approximate?(*arguments)
-    approximate.uncertain?(*arguments)
+  def approximate?(arguments = precision_filter)
+    approximate.uncertain?(arguments)
   end
   
   alias approximately? approximate?
   
-  def approximate!(*arguments)
-    approximate.uncertain!(*arguments)
+  def approximate!(arguments = precision_filter)
+    approximate.uncertain!(arguments)
     self
   end
   
   alias approximately! approximate!
   
-  def precise?(*arguments)
-    !approximate?(*arguments)
+  def precise?(arguments = precision_filter)
+    !approximate?(arguments)
   end
   
   alias precisely? precise?
 
-  def precise!(*arguments)
-    approximate.certain!(*arguments)
+  def precise!(arguments = precision_filter)
+    approximate.certain!(arguments)
     self
   end
 
@@ -109,15 +110,15 @@ class Date
   
   def_delegators :unspecified, :unspecified?, :specified?, :unsepcific?, :specific?
   
-  def unspecified!(*arguments)
-    unspecified.unspecified!(*arguments)
+  def unspecified!(arguments = precision_filter)
+    unspecified.unspecified!(arguments)
     self
   end
 
   alias unspecific! unspecified!
 
-  def specified!(*arguments)
-    unspecified.specified!(*arguments)
+  def specified!(arguments = precision_filter)
+    unspecified.specified!(arguments)
     self
   end
 
@@ -130,11 +131,13 @@ class Date
   end
   
   def edtf
-    FORMATS.take(values.length).join('-') % values
+    FORMATS.take(values.length).join('-') % values << (uncertain? ? '?' : '')
   end
 
 	alias to_edtf edtf
 	
+	# Returns a the Date of the next day, month, or year depending on the
+	# current Date/Time's precision.
   def next
     send("next_#{precision}")
   end
@@ -151,6 +154,8 @@ class Date
   # def ===(other)
   # end
   
+	# Returns an array of the current year, month, and day values filtered by
+	# the Date/Time's precision.
   def values
     precision_filter.map { |p| send(p) }
   end

data/lib/edtf/parser.y

@@ -2,9 +2,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
+token T Z E X U UNKNOWN OPEN LONGYEAR UNMATCHED DOTS IUA
 
 expect 0
 
@@ -13,253 +11,421 @@ rule
   edtf : level_0_expression
        | level_1_expression
        | level_2_expression
-       # | { result = Date.today }
-
+       ;
 
   # ---- Level 0 / ISO 8601 Rules ----
-  
+
+  # NB: level 0 intervals are covered by the level 1 interval rules
   level_0_expression : date
                      | date_time
-                     # | level_0_interval # --> level_1_interval
+                     ;
 
   date : positive_date
        | negative_date
+       ;
 
-  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 = -val[1] }
+  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 :  '-' positive_date { result = -val[1] }
 
-  date_time : date T time { result = DateTime.new(val[0].year, val[0].month, val[0].day, *val[2]) }
+
+  date_time : date T time {
+   result = DateTime.new(val[0].year, val[0].month, val[0].day, *val[2])
+  }
 
   time : base_time
        | base_time zone_offset { result = val.flatten }
-  
-  base_time : hour COLON minute COLON second { result = [val[0], val[2], val[4]] }
+
+  base_time : hour ':' minute ':' second { result = val.values_at(0, 2, 4) }
             | midnight
-  
-  midnight : D2 D4 COLON D0 D0 COLON D0 D0   { result = [24, 0, 0] }
-  
-  zone_offset : Z                            { result = 0 }
-              | MINUS zone_offset_hour       { result = -1 * val[1] }
-              | PLUS positive_zone_offset    { result = val[1] }
+
+  midnight : '2' '4' ':' '0' '0' ':' '0' '0' { result = [24, 0, 0] }
+
+  zone_offset : Z                        { result = 0 }
+              | '-' zone_offset_hour     { result = -1 * val[1] }
+              | '+' positive_zone_offset { result = val[1] }
+              ;
 
   positive_zone_offset : zone_offset_hour
-                       | D0 D0 COLON D0 D0   { result = 0 }
-              
-              
-  zone_offset_hour : d01_13 COLON minute     { result = Rational(val[0] * 60 + val[2], 1440) }
-                   | D1 D4 COLON D0 D0       { result = Rational(840, 1440) }
-                   | D0 D0 COLON d01_59      { result = Rational(val[3], 1440) }
-  
-  year : digit digit digit digit { result = val.zip([1000,100,10,1]).reduce(0) { |s,(a,b)| s += a * b } }
-  
+                       | '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) }
+                   ;
+
+  year : digit digit digit digit {
+    result = val.zip([1000,100,10,1]).reduce(0) { |s,(a,b)| s += a * b }
+  }
+
   month : d01_12
-      
-  year_month : year MINUS month         { result = [val[0], val[2]] }
-  
+   
+  year_month : year '-' month { result = [val[0], val[2]] }
+
   # We raise an exception if there are two many days for the month, but
   # do not consider leap years, as the EDTF BNF did not either.
   # NB: an exception will be raised regardless, because the Ruby Date
   # implementation calculates leap years.
-  year_month_day : year_month MINUS d01_31 { result = val[0] << val[2]; raise ArgumentError, "invalid date (invalid days #{result[2]} for month #{result[1]})" if result[2] > 31 || (result[2] > 30 && [2,4,6,9,11].include?(result[1])) || (result[2] > 29 && result[1] == 2) }
+  year_month_day : year_month '-' d01_31 {
+    result = val[0] << val[2]
+    if result[2] > 31 || (result[2] > 30 && [2,4,6,9,11].include?(result[1])) || (result[2] > 29 && result[1] == 2)
+      raise ArgumentError, "invalid date (invalid days #{result[2]} for month #{result[1]})"
+    end
+  }
 
-  hour : d00_23
-  
+  hour   : d00_23
   minute : d00_59
-  
   second : d00_59
-  
-  # covered by level_1_interval
-  # level_0_interval : date SLASH date   { result = Interval.new(val[0], val[1]) }
+
+  # Completely covered by level_1_interval
+  # level_0_interval : date '/' date { result = Interval.new(val[0], val[1]) }
+
 
   # ---- Level 1 Extension Rules ----
-  
-  level_1_expression : uncertain_or_approximate_date 
-                     | unspecified 
-                     | level_1_interval
-                     | long_year_simple
-                     | season
-  
 
-  uncertain_or_approximate_date : date uncertain_or_approximate { result = val[0]; val[1].each { |m| result.send(m) } }
-  
-  uncertain_or_approximate : UNCERTAIN              { result = [:uncertain!] }
-                           | APPROXIMATE            { result = [:approximate!] }
-                           | UNCERTAIN APPROXIMATE  { result = [:uncertain!, :approximate!] }
-  
+  # NB: Uncertain/approximate Dates are covered by the Level 2 rules
+  level_1_expression : unspecified | level_1_interval | long_year_simple | season
+
+  # uncertain_or_approximate_date : date ua { result = uoa(val[0], val[1]) }
 
-  unspecified : unspecified_year          { result = Date.new(val[0][0]); result.unspecified.year[2,2] = val[0][1]; result.precision = :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 = [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); result.precision = :month }
-  
-  unspecified_day : year_month MINUS UNSPECIFIED UNSPECIFIED { result = Date.new(*val[0]).unspecified!(:day) }
-  
-  unspecified_day_and_month : year MINUS UNSPECIFIED UNSPECIFIED MINUS UNSPECIFIED UNSPECIFIED { result = Date.new(val[0]).unspecified!([:day,:month]) }
+              ;
+
+  unspecified_year :
+    digit digit digit U
+    {
+      result = [val[0,3].zip([1000,100,10]).reduce(0) { |s,(a,b)| s += a * b }, [false,true]]
+    }
+    | digit digit U U
+    {
+      result = [val[0,2].zip([1000,100]).reduce(0) { |s,(a,b)| s += a * b }, [true, true]]
+    }
+
+  unspecified_month : year '-' U U {
+    result = Date.new(val[0]).unspecified!(:month)
+    result.precision = :month
+  }
 
+  unspecified_day : year_month '-' U U {
+    result = Date.new(*val[0]).unspecified!(:day)
+  }
 
-  level_1_interval : level_1_start SLASH level_1_end { result = Interval.new(val[0], val[2]) }
+  unspecified_day_and_month : year '-' U U '-' U U {
+    result = Date.new(val[0]).unspecified!([:day,:month])
+  }
 
-  level_1_start : date
-                | uncertain_or_approximate_date
-                | UNKNOWN                        { result = :unknown }
-                
-  level_1_end : level_1_start
-              | OPEN                             { result = :open }
 
+  level_1_interval : level_1_start '/' level_1_end {
+    result = Interval.new(val[0], 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] }
+  level_1_start : date | internal_uncertain_or_approximate_date | UNKNOWN
+             
+  level_1_end : level_1_start | OPEN
+
+
+  long_year_simple :
+    LONGYEAR long_year
+    {
+      result = Date.new(val[1])
+      result.precision = :year
+    }
+    | LONGYEAR '-' 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 = Season.new(val[0], val[2]) }
+  season : year '-' season_number { result = Season.new(val[0], val[2]) }
 
-  season_number : D2 D1 { result = 21 }
-                | D2 D2 { result = 22 }
-                | D2 D3 { result = 23 }
-                | D2 D4 { result = 24 }
+  season_number : '2' '1' { result = 21 }
+                | '2' '2' { result = 22 }
+                | '2' '3' { result = 23 }
+                | '2' '4' { result = 24 }
+                ;
 
 
   # ---- Level 2 Extension Rules ----
-  
+
+  # NB: Level 2 Intervals are covered by the Level 1 Interval rules.
   level_2_expression : season_qualified
-                     # | internal_uncertain_or_approximate
+                     | internal_uncertain_or_approximate_date
                      | internal_unspecified
                      | choice_list
                      | inclusive_list
                      | masked_precision
-                     # | level_2_interval
                      | date_and_calendar
                      | long_year_scientific
-  
+                     ;
 
-  season_qualified : season CARET { result = val[0]; result.qualifier = val[1] }
 
+  season_qualified : season '^' { result = val[0]; result.qualifier = val[1] }
 
-  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] }
-  
+  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 '-' int1_4 E integer
+		{
+			result = Date.new(-1 * val[2] * 10 ** val[4])
+			result.precision = :year
+		}
+		;
 
-  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]] }
+  date_and_calendar : date '^' { result = val[0]; result.calendar = val[1] }
+
+
+  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 : '[' list ']' { result = val[1] }
+
+  inclusive_list : '{' list '}' { result = val[1] }
+
+  list : earlier                              { result = val }
+       | earlier ',' list_elements ',' later  { result = [val[0]] + val[2] + [val[4]] }
+       | earlier ',' list_elements            { result = [val[0]] + val[2] }
+       | earlier ',' later                    { result = [val[0]] + [val[2]] }
+       | list_elements ',' 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 }
-                
+       | later                                { result = val }
+			 ;
+        
+  list_elements : list_element                   { result = [val[0]].flatten }
+                | list_elements ',' list_element { result = val[0] + [val[2]].flatten }
+								;
+             
   list_element : date
-               # | date_with_internal_uncertainty
-               | uncertain_or_approximate_date
+               | internal_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 { 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) }
-  
+               | year DOTS year { result = (val[0]..val[2]).to_a.map }
+							 ;
+
+  internal_unspecified :
+    unspecified_year '-' month '-' d01_31
+    {
+      result = Date.new(val[0][0], val[2], val[4])
+      result.unspecified.year[2,2] = val[0][1]
+    }
+    | unspecified_year '-' U U '-' d01_31
+    {
+      result = Date.new(val[0][0], 1, val[5])
+      result.unspecified.year[2,2] = val[0][1]
+      result.unspecified!(:month)
+    }
+    | unspecified_year '-' U U '-' U U
+    {
+      result = Date.new(val[0][0], 1, 1)
+      result.unspecified.year[2,2] = val[0][1]
+      result.unspecified!([:month, :day])
+    }
+    | unspecified_year '-' month '-' U U
+    {
+      result = Date.new(val[0][0], val[2], 1)
+      result.unspecified.year[2,2] = val[0][1]
+      result.unspecified!(:day)
+    }
+    | year '-' U U '-' d01_31
+    {
+      result = Date.new(val[0], 1, val[5])
+      result.unspecified!(:month)
+    }
+    ;
+ 
+  internal_uncertain_or_approximate_date : internal_uncertain_or_approximate
+    | '(' internal_uncertain_or_approximate ')' ua { result = uoa(val[1], val[3]) }
+
+  internal_uncertain_or_approximate :
+    iua_year             { result = val[0]; result.precision = :year }
+    | iua_year_month     { result = val[0]; result.precision = :month }
+    | iua_year_month_day
+
+  iua_year : year ua { result = uoa(Date.new(val[0]), val[1], :year) }
+
+  iua_year_month :
+    iua_year '-' month opt_ua
+    {
+      result = uoa(val[0].change(:month => val[2]), val[3], [:month, :year])
+    }
+    | '(' iua_year IUA month opt_ua
+    {
+      result = uoa(uoa(val[1], val[2], :year).change(:month => val[3]), val[4], :month)
+    }
+    | year '-' month ua
+    {
+      result = uoa(Date.new(val[0], val[2]), val[3], [:year, :month])
+    }
+    | year '-' '(' month ')' ua
+    {
+      result = uoa(Date.new(val[0], val[3]), val[5], [:month])
+    }
+    ;
+
+  iua_year_month_day :
+    iua_year_month '-' d01_31 opt_ua
+    {
+      result = uoa(val[0].change(:day => val[2]), val[3])
+    }
+    | iua_year_month '-' '(' d01_31 ')' ua
+    {
+      result = uoa(val[0].change(:day => val[3]), val[5], [:day])
+    }
+    | '(' iua_year_month IUA d01_31 opt_ua
+    {
+      result = uoa(uoa(val[1], val[2], [:year, :month]).change(:day => val[3]), val[4], :day)
+    }
+    | year '-' '(' month IUA d01_31 opt_ua
+    {
+      result = uoa(uoa(Date.new(val[0], val[3], val[5]), val[4], :month), val[6], :day)
+    }
+    | year_month '-' d01_31 ua
+    {
+      result = uoa(Date.new(val[0][0], val[0][1], val[2]), val[3])
+    }
+    | year_month '-' '(' d01_31 ')' ua
+    {
+      result = uoa(Date.new(val[0][0], val[0][1], val[3]), val[5], [:day])
+    }
+    | year '-' '(' month '-' d01_31 ')' ua
+    {
+      result = uoa(Date.new(val[0], val[3], val[5]), val[7], [:month, :day])
+    }
+    ;
+ 
+  opt_ua : { result = [] } | ua
+
+  ua : '?'
+     | '~'
+     | '?' '~'  { result = val.flatten }
+     ;
 
   # ---- Auxiliary Rules ----
 
-  digit : D0             { result = 0 }
+  digit : '0' { result = 0 }
         | positive_digit
-        
-  positive_digit : D1 { result = 1 }
-                 | D2 { result = 2 }
-                 | D3 { result = 3 }
-                 | D4 { result = 4 }
-                 | D5 { result = 5 }
-                 | D6 { result = 6 }
-                 | D7 { result = 7 }
-                 | D8 { result = 8 }
-                 | D9 { result = 9 }
-
-  d01_12 : D0 positive_digit { result = val[1] }
-         | D1 D0             { result = 10 }
-         | D1 D1             { result = 11 }
-         | D1 D2             { result = 12 }
+        ;
+    
+  positive_digit : '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
+
+  d01_12 : '0' positive_digit { result = val[1] }
+         | '1' '0'            { result = 10 }
+         | '1' '1'            { result = 11 }
+         | '1' '2'            { result = 12 }
+         ;
 
   d01_13 : d01_12
-         | D1 D3             { result = 13 }
-         
-  d01_23 : D0 positive_digit { result = val[1] }
-         | D1 digit          { result = 10 + val[1] }
-         | D2 D0             { result = 20 }
-         | D2 D1             { result = 21 }
-         | D2 D2             { result = 22 }
-         | D2 D3             { result = 23 }
-
-  d00_23 : D0 D0             { result = 0  }
+         | '1' '3'            { result = 13 }
+         ;
+     
+  d01_23 : '0' positive_digit { result = val[1] }
+         | '1' digit          { result = 10 + val[1] }
+         | '2' '0'            { result = 20 }
+         | '2' '1'            { result = 21 }
+         | '2' '2'            { result = 22 }
+         | '2' '3'            { result = 23 }
+         ;
+
+  d00_23 : '0' '0'
          | d01_23
+         ;
 
   d01_29 : d01_23
-         | D2 D4             { result = 24 }
-         | D2 D5             { result = 25 }
-         | D2 D6             { result = 26 }
-         | D2 D7             { result = 27 }
-         | D2 D8             { result = 28 }
-         | D2 D9             { result = 29 }
+         | '2' '4' { result = 24 }
+         | '2' '5' { result = 25 }
+         | '2' '6' { result = 26 }
+         | '2' '7' { result = 27 }
+         | '2' '8' { result = 28 }
+         | '2' '9' { result = 29 }
+         ;
 
   d01_30 : d01_29
-         | D3 D0             { result = 30 }
+         | '3' '0' { result = 30 }
+         ;
 
   d01_31 : d01_30
-         | D3 D1             { result = 31 }
-  
+         | '3' '1' { result = 31 }
+         ;
+
   d01_59 : d01_29
-         | D3 digit          { result = 30 + val[1] }
-         | D4 digit          { result = 40 + val[1] }
-         | D5 digit          { result = 50 + val[1] }
-         
-  d00_59 : D0 D0             { result = 0 }
+         | '3' digit { result = 30 + val[1] }
+         | '4' digit { result = 40 + val[1] }
+         | '5' digit { result = 50 + val[1] }
+         ;
+    
+  d00_59 : '0' '0'
          | d01_59
-
-  int1_4 : positive_digit                  { result = val[0] }
-        | positive_digit digit             { result = 10 * val[0] + val[1] }
-        | positive_digit digit digit       { result = val.zip([100,10,1]).reduce(0) { |s,(a,b)| s += a * b } }
-        | positive_digit digit digit digit { result = val.zip([1000,100,10,1]).reduce(0) { |s,(a,b)| s += a * b } }
+         ;
+
+  int1_4 : positive_digit              { result = val[0] }
+         | positive_digit digit        { result = 10 * val[0] + val[1] }
+         | positive_digit digit digit
+         {
+           result = val.zip([100,10,1]).reduce(0) { |s,(a,b)| s += a * b }
+         }
+         | positive_digit digit digit digit
+         {
+           result = val.zip([1000,100,10,1]).reduce(0) { |s,(a,b)| s += a * b }
+         }
+         ;
 
   integer : positive_digit { result = val[0] }
-         | integer digit   { result = 10 * val[0] + val[1] }
+          | integer digit  { result = 10 * val[0] + val[1] }
+          ;
 
 
 
@@ -291,63 +457,78 @@ require 'strscan'
     warn "failed to parse extended date time %s (%s) %s" % [val.inspect, token_to_str(tid) || '?', vstack.inspect]
   end
 
+  def apply_uncertainty(date, uncertainty, scope = nil)
+    uncertainty.each do |u|
+      scope.nil? ? date.send(u) : date.send(u, scope)
+    end
+    date
+  end
+  
+  alias uoa apply_uncertainty
+  
   def next_token
-		case
-		when @src.eos?
-			nil
-	  # when @src.scan(/\s+/)
-	    # ignore whitespace
-	  when @src.scan(/\(/)
-	    [:LP, @src.matched]
-	  when @src.scan(/\)/)
-	    [:RP, @src.matched]
-	  when @src.scan(/\[/)
-	    [:LSQUARE, @src.matched]
-	  when @src.scan(/\]/)
-	    [:RSQUARE, @src.matched]
-	  when @src.scan(/\{/)
-	    [:LBRACE, @src.matched]
-	  when @src.scan(/\}/)
-	    [:RBRACE, @src.matched]
-	  when @src.scan(/T/)
-	    [:T, @src.matched]
-	  when @src.scan(/Z/)
-	    [:Z, @src.matched]
-	  when @src.scan(/\?/)
-	    [:UNCERTAIN, @src.matched]
-	  when @src.scan(/~/)
-	    [:APPROXIMATE, @src.matched]
-	  when @src.scan(/open/i)
-	    [:OPEN, @src.matched]
-	  when @src.scan(/unkn?own/i) # matches 'unkown' typo too
-	    [:UNKNOWN, @src.matched]
-	  when @src.scan(/u/)
-	    [:UNSPECIFIED, @src.matched]
-	  when @src.scan(/x/i)
-	    [:X, @src.matched]
-	  when @src.scan(/y/)
-	    [:LONGYEAR, @src.matched]
-	  when @src.scan(/e/)
-	    [:E, @src.matched]
-	  when @src.scan(/\+/)
-	    [:PLUS, @src.matched]
-	  when @src.scan(/-/)
-	    [:MINUS, @src.matched]
-	  when @src.scan(/:/)
-	    [:COLON, @src.matched]
-	  when @src.scan(/\//)
-	    [:SLASH, @src.matched]
-	  when @src.scan(/\s*\.\.\s*/)
-	    [:DOTS, '..']
-	  when @src.scan(/\s*,\s*/)
-	    [:COMMA, ',']
-	  when @src.scan(/\^\w+/)
-	    [:CARET, @src.matched[1..-1]]
-	  when @src.scan(/\d/)
-	    [['D', @src.matched].join.intern, @src.matched]
-	  else @src.scan(/./)
-	    [:UNMATCHED, @src.rest]
-	  end
+    case
+    when @src.eos?
+      nil
+    # when @src.scan(/\s+/)
+      # ignore whitespace
+    when @src.scan(/\(/)
+      ['(', @src.matched] 
+    when @src.scan(/\)\?~-/)
+      [:IUA, [:uncertain!, :approximate!]]
+    when @src.scan(/\)\?-/)
+      [:IUA, [:uncertain!]]
+    when @src.scan(/\)~-/)
+      [:IUA, [:approximate!]]
+    when @src.scan(/\)/)
+      [')', @src.matched]
+    when @src.scan(/\[/)
+      ['[', @src.matched]
+    when @src.scan(/\]/)
+      [']', @src.matched]
+    when @src.scan(/\{/)
+      ['{', @src.matched]
+    when @src.scan(/\}/)
+      ['}', @src.matched]
+    when @src.scan(/T/)
+      [:T, @src.matched]
+    when @src.scan(/Z/)
+      [:Z, @src.matched]
+    when @src.scan(/\?/)
+      ['?', [:uncertain!]]
+    when @src.scan(/~/)
+      ['~', [:approximate!]]
+    when @src.scan(/open/i)
+      [:OPEN, :open]
+    when @src.scan(/unkn?own/i) # matches 'unkown' typo too
+      [:UNKNOWN, :unknown]
+    when @src.scan(/u/)
+      [:U, @src.matched]
+    when @src.scan(/x/i)
+      [:X, @src.matched]
+    when @src.scan(/y/)
+      [:LONGYEAR, @src.matched]
+    when @src.scan(/e/)
+      [:E, @src.matched]
+    when @src.scan(/\+/)
+      ['+', @src.matched]
+    when @src.scan(/-/)
+      ['-', @src.matched]
+    when @src.scan(/:/)
+      [':', @src.matched]
+    when @src.scan(/\//)
+      ['/', @src.matched]
+    when @src.scan(/\s*\.\.\s*/)
+      [:DOTS, '..']
+    when @src.scan(/\s*,\s*/)
+      [',', ',']
+    when @src.scan(/\^\w+/)
+      ['^', @src.matched[1..-1]]
+    when @src.scan(/\d/)
+      [@src.matched, @src.matched.to_i]
+    else @src.scan(/./)
+      [:UNMATCHED, @src.rest]
+    end
   end