edtf 0.0.1

data/lib/edtf/date.rb

@@ -0,0 +1,77 @@
+module EDTF
+  
+  module ExtendedDate
+    
+    extend Forwardable
+    
+    include Seasons
+    
+    attr_accessor :calendar
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    def uncertain
+      @uncertain ||= Uncertainty.new
+    end
+
+    def approximate
+      @approximate ||= Uncertainty.new
+    end
+
+    def unspecified
+      @unspecified ||= Unspecified.new
+    end
+    
+    def_delegators :uncertain, :uncertain?, :certain?
+
+    def certain!(*arguments)
+      uncertain.certain!(*arguments)
+      self
+    end
+    
+    def uncertain!(*arguments)
+      uncertain.uncertain!(*arguments)
+      self
+    end
+
+    def approximate?(*arguments)
+      approximate.uncertain?(*arguments)
+    end
+    
+    def approximate!(*arguments)
+      approximate.uncertain!(*arguments)
+      self
+    end
+    
+    def precise!(*arguments)
+      approximate.certain!(*arguments)
+      self
+    end
+
+    def_delegators :unspecified, :unspecified?, :specified?, :unsepcific?, :specific?
+    
+    def unspecified!(*arguments)
+      unspecified.unspecified!(*arguments)
+      self
+    end
+
+    alias unspecific! unspecified!
+
+    def specified!(*arguments)
+      unspecified.specified!(*arguments)
+      self
+    end
+
+    alias specific! specified!
+          
+    module ClassMethods  
+      def edtf(input, options = {})
+        ::EDTF::Parser.new(options).parse(input)
+      end
+    end
+    
+  end
+  
+end

data/lib/edtf/extensions.rb

@@ -0,0 +1,4 @@
+
+class Date
+  include EDTF::ExtendedDate
+end

data/lib/edtf/interval.rb

@@ -0,0 +1,66 @@
+module EDTF
+  
+  class Interval
+
+    extend Forwardable
+
+    include Enumerable
+    
+    def_delegators :to_range, *(Range.instance_methods - Enumerable.instance_methods - Object.instance_methods)
+
+    attr_reader :from, :to
+    
+    def initialize(from = :open, to = :open)
+      @from, @to = from, to
+    end
+    
+    def from=(from)
+      @from = from || :open
+    end
+
+    def to=(to)
+      @to = to || :open
+    end
+
+    [:open, :unknown].each do |method_name|
+      
+      define_method("#{method_name}?") do
+        @to == method_name || @from == method_name
+      end
+
+      define_method("#{method_name}!") do
+        @to = method_name
+      end
+
+      alias_method("#{method_name}_end!", "#{method_name}!")
+      
+      define_method("#{method_name}_end?") do
+        @to == method_name
+      end
+      
+    end
+
+    def unknown_start?
+      @from == :unknown
+    end
+    
+    def unknown_start!
+      @from = :unknown
+    end
+    
+    # TODO how to handle +/- Infinity for Dates?
+    
+    def to_range
+      case
+      when open?
+        nil
+      when unknown_end?
+        nil
+      else
+        Range.new(unknown_start? ? Date.new : from, to)
+      end
+    end
+    
+  end
+  
+end

data/lib/edtf/parser.y

@@ -0,0 +1,313 @@
+# -*- racc -*-
+
+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
+
+expect 0
+
+rule
+
+  edtf : level_0_expression
+       | level_1_expression
+       | level_2_expression
+       # | { result = Date.today }
+
+
+  # ---- Level 0 / ISO 8601 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]) }
+                | year_month     { result = Date.new(*val.flatten) }
+                | year_month_day { result = Date.new(*val.flatten) }
+                
+  negative_date :  MINUS positive_date { result = Date.new(-1 * val[1].year, val[1].month, val[1].day) }
+
+
+  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]] }
+            | 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] }
+
+  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 } }
+  
+  month : d01_12
+      
+  year_month : year MINUS 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) }
+
+  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]) }
+
+  # ---- 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!] }
+  
+
+  unspecified : unspecified_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_month : year MINUS UNSPECIFIED UNSPECIFIED { result = Date.new(val[0]).unspecified!(: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]) }
+
+
+  level_1_interval : level_1_start SLASH level_1_end { result = Interval.new(val[0], val[2]) }
+
+  level_1_start : date
+                | uncertain_or_approximate_date
+                | UNKNOWN                        { result = :unknown }
+                
+  level_1_end : level_1_start
+              | 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 : 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_number : D2 D1 { result = 21 }
+                | D2 D2 { result = 22 }
+                | D2 D3 { result = 23 }
+                | D2 D4 { result = 24 }
+
+
+  # ---- Level 2 Extension Rules ----
+  
+  level_2_expression : season_qualified
+                     # | internal_uncertain_or_approximate
+                     # | 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] }
+
+
+  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]) }
+  
+
+  date_and_calendar : date CARET { 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) }
+
+  # ---- Auxiliary Rules ----
+
+  digit : D0             { 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 }
+
+  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  }
+         | 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 }
+
+  d01_30 : d01_29
+         | D3 D0             { result = 30 }
+
+  d01_31 : d01_30
+         | D3 D1             { 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 }
+         | 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 } }
+
+  integer : positive_digit { result = val[0] }
+         | integer digit   { result = 10 * val[0] + val[1] }
+
+
+
+---- header
+require 'strscan'
+
+---- inner
+
+  @defaults = {
+    :level => 2,
+    :debug => false
+  }
+  
+  class << self; attr_reader :defaults; end
+  
+  attr_reader :options
+  
+  def initialize(options = {})
+    @options = Parser.defaults.merge(options)
+  end
+  
+  def parse(input)
+    @yydebug = @options[:debug] || ENV['DEBUG']
+    scan(input)
+    do_parse
+  end
+  
+  def next_token
+    @stack.shift
+  end
+
+  def on_error(tid, val, vstack)
+    warn "failed to parse extended date time %s (%s) %s" % [val.inspect, token_to_str(tid) || '?', vstack.inspect]
+  end
+
+  def scan(input)
+    @src = StringScanner.new(input)
+    @stack = []
+    tokenize
+  end
+
+  private
+
+  def tokenize
+    until @src.eos?
+      case
+      when @src.scan(/\(/)
+        @stack << [:LP, @src.matched]
+      when @src.scan(/\)/)
+        @stack << [:RP, @src.matched]
+      when @src.scan(/T/)
+        @stack << [:T, @src.matched]
+      when @src.scan(/Z/)
+        @stack << [:Z, @src.matched]
+      when @src.scan(/\?/)
+        @stack << [:UNCERTAIN, @src.matched]
+      when @src.scan(/~/)
+        @stack << [:APPROXIMATE, @src.matched]
+      when @src.scan(/open/i)
+        @stack << [:OPEN, @src.matched]
+      when @src.scan(/unkn?own/i) # matches 'unkown' typo too
+        @stack << [:UNKNOWN, @src.matched]
+      when @src.scan(/u/)
+        @stack << [:UNSPECIFIED, @src.matched]
+      when @src.scan(/x/i)
+        @stack << [:X, @src.matched]
+      when @src.scan(/y/)
+        @stack << [:LONGYEAR, @src.matched]
+      when @src.scan(/e/)
+        @stack << [:E, @src.matched]
+      when @src.scan(/\+/)
+        @stack << [:PLUS, @src.matched]
+      when @src.scan(/-/)
+        @stack << [:MINUS, @src.matched]
+      when @src.scan(/:/)
+        @stack << [:COLON, @src.matched]
+      when @src.scan(/\//)
+        @stack << [:SLASH, @src.matched]
+      when @src.scan(/\^\w+/)
+        @stack << [:CARET, @src.matched[1..-1]]
+      when @src.scan(/\d/)
+        @stack << [['D', @src.matched].join.intern, @src.matched]
+      else @src.scan(/./)
+        @stack << [:UNMATCHED, @src.rest]
+      end
+    end
+  
+    @stack
+  end
+
+
+# -*- racc -*-