edtf 0.0.6 → 0.0.7

data/lib/edtf/parser.y

@@ -2,7 +2,7 @@
 
 class EDTF::Parser
 
-token T Z E X U UNKNOWN OPEN LONGYEAR UNMATCHED DOTS IUA
+token T Z E X U UNKNOWN OPEN LONGYEAR UNMATCHED DOTS PUA
 
 expect 0
 
@@ -133,7 +133,7 @@ rule
     result = Interval.new(val[0], val[2])
   }
 
-  level_1_start : date | internal_uncertain_or_approximate_date | UNKNOWN
+  level_1_start : date | partial_uncertain_or_approximate | unspecified | partial_unspecified | UNKNOWN
              
   level_1_end : level_1_start | OPEN
 
@@ -159,7 +159,7 @@ rule
     ;
 
 
-  season : year '-' season_number { result = Season.new(val[0], val[2]) }
+  season : year '-' season_number opt_ua { result = Season.new(val[0], val[2]) }
 
   season_number : '2' '1' { result = 21 }
                 | '2' '2' { result = 22 }
@@ -172,8 +172,8 @@ rule
 
   # NB: Level 2 Intervals are covered by the Level 1 Interval rules.
   level_2_expression : season_qualified
-                     | internal_uncertain_or_approximate_date
-                     | internal_unspecified
+                     | partial_uncertain_or_approximate
+                     | partial_unspecified
                      | choice_list
                      | inclusive_list
                      | masked_precision
@@ -239,7 +239,7 @@ rule
 								;
              
   list_element : date
-               | internal_uncertain_or_approximate_date
+               | partial_uncertain_or_approximate
                | unspecified
                | consecutives { result = val[0].map { |d| Date.new(*d) } }
 							 ;
@@ -256,7 +256,7 @@ rule
                | year DOTS year { result = (val[0]..val[2]).to_a.map }
 							 ;
 
-  internal_unspecified :
+  partial_unspecified :
     unspecified_year '-' month '-' d01_31
     {
       result = Date.new(val[0][0], val[2], val[4])
@@ -287,22 +287,23 @@ rule
     }
     ;
  
-  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
+  partial_uncertain_or_approximate : pua_base
+    | '(' pua_base ')' ua { result = uoa(val[1], val[3]) }
+  
+  pua_base :
+    pua_year             { result = val[0]; result.precision = :year }
+    | pua_year_month     { result = val[0]; result.precision = :month }
+    | pua_year_month_day
+  
+  pua_year : year ua { result = uoa(Date.new(val[0]), val[1], :year) }
+  
+  pua_year_month :
+    pua_year '-' month opt_ua
     {
       result = uoa(val[0].change(:month => val[2]), val[3], [:month, :year])
     }
-    | '(' iua_year IUA month opt_ua
+    | '(' pua_year PUA month opt_ua
     {
       result = uoa(uoa(val[1], val[2], :year).change(:month => val[3]), val[4], :month)
     }
@@ -315,21 +316,21 @@ rule
       result = uoa(Date.new(val[0], val[3]), val[5], [:month])
     }
     ;
-
-  iua_year_month_day :
-    iua_year_month '-' d01_31 opt_ua
+  
+  pua_year_month_day :
+    pua_year_month '-' d01_31 opt_ua
     {
       result = uoa(val[0].change(:day => val[2]), val[3])
     }
-    | iua_year_month '-' '(' d01_31 ')' ua
+    | pua_year_month '-' '(' d01_31 ')' ua
     {
       result = uoa(val[0].change(:day => val[3]), val[5], [:day])
     }
-    | '(' iua_year_month IUA d01_31 opt_ua
+    | '(' pua_year_month PUA 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
+    | year '-' '(' month PUA d01_31 opt_ua
     {
       result = uoa(uoa(Date.new(val[0], val[3], val[5]), val[4], :month), val[6], :day)
     }
@@ -447,14 +448,22 @@ require 'strscan'
     @options = Parser.defaults.merge(options)
   end
   
-  def parse(input)
+	def parse(input)
+		parse!(input)
+	rescue => e
+		warn e.message if options[:debug]
+		nil
+	end
+	
+  def parse!(input)
     @yydebug = @options[:debug] || ENV['DEBUG']
     @src = StringScanner.new(input)
     do_parse
   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]
+    raise ArgumentError,
+			"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)
@@ -475,11 +484,11 @@ require 'strscan'
     when @src.scan(/\(/)
       ['(', @src.matched] 
     when @src.scan(/\)\?~-/)
-      [:IUA, [:uncertain!, :approximate!]]
+      [:PUA, [:uncertain!, :approximate!]]
     when @src.scan(/\)\?-/)
-      [:IUA, [:uncertain!]]
+      [:PUA, [:uncertain!]]
     when @src.scan(/\)~-/)
-      [:IUA, [:approximate!]]
+      [:PUA, [:approximate!]]
     when @src.scan(/\)/)
       [')', @src.matched]
     when @src.scan(/\[/)

data/lib/edtf/season.rb

@@ -28,7 +28,8 @@ module EDTF
     
     attr_accessor :qualifier
     
-    def_delegators :to_range, :each
+    def_delegators :to_range,
+      *Range.instance_methods(false).reject { |m| m.to_s =~ /^(each|eql?|hash)$/ }
     
     SEASONS.each_value do |s|
       define_method("#{s}?") { @season == s }
@@ -65,6 +66,15 @@ module EDTF
       end
     end
 
+    def each
+      if block_given?
+        to_range(&Proc.new)
+        self
+      else
+        to_enum
+      end
+    end
+    
     def year=(new_year)
       @year = new_year.to_i
     end
@@ -82,12 +92,12 @@ module EDTF
       '%04d-%2d%s' % [year, CODES[season], qualified? ? "^#{qualifier}" : '']
     end
 
-    alias to_edtf to_s
+    alias edtf to_s
     
     def <=>(other)
       case other
       when Date
-        include?(other) ? 0 : to_date <=> other
+        cover?(other) ? 0 : to_date <=> other
       when Season
         [year, month, qualifier] <=> [other.year, other.month, other.qualifier]
       else
@@ -104,22 +114,13 @@ module EDTF
     end
     
     def to_date
-      Date.new(year, month)
+      Date.new(year, month, 1)
     end
 
-    # def include?(other)
-    #   case other
-    #   when Date
-    #     d = to_date
-    #     other >= d && other <= d.months_since(3).end_of_month
-    #   else
-    #     false
-    #   end
-    # end
-    
+    # Returns a Range that covers the season (a three month period).
     def to_range
       d = to_date
-      d .. d.months_since(3).end_of_month
+      d .. d.months_since(2).end_of_month
     end
     
     protected

data/lib/edtf/uncertainty.rb

@@ -1,59 +1,95 @@
 module EDTF
- 
-  class Uncertainty < Struct.new(:year, :month, :day, :hour, :minute, :second)
-        
+
+  # TODO use bitmasks instead of arrays
+
+  class Uncertainty < Struct.new(:year, :month, :day)
+
+    attr_reader :hash_base
+    
+    def initialize(year = nil, month = nil, day = nil, hash_base = 1)
+      @hash_base = hash_base
+      super(year, month, day)
+    end
+    
+    def hash_base=(base)
+      @hash_map = false
+      @hash_base = base
+    end
+    
     def uncertain?(parts = members)
-      [parts].flatten.any? { |p| !!send(p) }
+      [*parts].any? { |p| !!send(p) }
     end
 
     def uncertain!(parts = members)
-      [parts].flatten.each { |p| send("#{p}=", true) }
+      [*parts].each { |p| send("#{p}=", true) }
       self
     end
 
     def certain?(parts = members); !uncertain?(parts); end
-    
+
     def certain!(parts = members)
-      [parts].flatten.each { |p| send("#{p}=", false) }
+      [*parts].each { |p| send("#{p}=", false) }
       self
     end
+    
+    def eql?(other)
+      hash == other.hash
+    end
+    
+    def hash
+      values.zip(hash_map).reduce(0) { |s, (v, h)|  s + (v ? h : 0) }
+    end
+    
+    private 
+    
+    def hash_map
+      @hash_map ||= (0...length).map { |i| hash_base << i }
+    end
+    
   end
 
-  # year = []
+
   class Unspecified < Struct.new(:year, :month, :day)
-    
+
+    U = 'u'.freeze
+
     def initialize
-      super year = Array.new(4), month = Array.new(2), day = Array.new(2)
+      super Array.new(4),Array.new(2), Array.new(2)
     end
-    
+
     def unspecified?(parts = members)
-      [parts].flatten.any? { |p| send(p).any? { |u| !!u } }
+      [*parts].any? { |p| send(p).any? { |u| !!u } }
     end
-    
+
     def unspecified!(parts = members)
-      [parts].flatten.each { |p| send(p).map! { true } }
+      [*parts].each { |p| send(p).map! { true } }
       self
     end
 
     def specified?(parts = members); !unspecified?(parts); end
 
     def specified!(parts = members)
-      [parts].flatten.each { |p| send(p).map! { false } }
+      [*parts].each { |p| send(p).map! { false } }
       self
     end
-    
+
     alias specific? specified?
     alias unspecific? unspecified?
 
     alias specific! specified!
     alias unspecific! unspecified!
-    
+
     private :year=, :month=, :day=
-    
+
     def to_s
-      [year, month, day].map { |p| p.map { |i| i ? 'u' : 's' }.join }.join('-')
+      mask(%w{ ssss ss ss }).join('-')
+    end
+
+    def mask(values)
+      values.zip(members.take(values.length)).map do |value, mask|
+        value.split(//).zip(send(mask)).map { |v,m| m ? U : v }.join
+      end
     end
-    
   end
-  
+
 end

data/lib/edtf/version.rb

@@ -1,3 +1,3 @@
 module EDTF
-  VERSION = '0.0.6'.freeze
+  VERSION = '0.0.7'.freeze
 end

data/spec/edtf/date_spec.rb

@@ -38,29 +38,83 @@ describe 'Date/DateTime' do
     end
     
   end
+
+	describe 'precisions' do
+		let(:date) { Date.today }
+		
+		it 'has day precision by default' do
+			date.should 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
+		end
+		
+	end
+	
   
 	describe '#negate' do
     let(:date) { Date.edtf('2004?') }
 		
-		it 'should return a new date with the negated year' do
+		it 'returns a new date with the negated year' do
 			date.negate.year.should == (date.year * -1)
 		end
 		
-		it 'should return a new date with the same month and day' do
+		it 'returns a new date with the same month' do
 			date.negate.month.should == date.month
+		end
+		
+		it 'returns a new date with the same day' do
 			date.negate.day.should == date.day
 		end
 		
-		it 'should return a new date with the same precision' do
+		it 'returns a new date with the same precision' do
 			date.negate.precision.should == date.precision
 		end
 	end
 	
+	describe '#succ' do
+		
+		it 'the successor of 2004 is 2005' do
+			Date.edtf('2004').succ.year.should == 2005
+		end
+
+		it 'the successor of 2004-03 is 2004-04' do
+			Date.edtf('2004-03').succ.strftime('%Y-%m').should == '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'
+		end
+
+		it "the successor of 1999 has year precision" do
+			Date.edtf('1999').succ.should be_year_precision
+		end
+
+	end
+	
+	describe '#next' do
+	  
+	  it 'returns the successor when given no argument' do
+			Date.edtf('1999').next.year.should == 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
       date.change({}).should == date
+		end
+		
+    it 'the returned copy is not identical at object level' do
       date.change({}).should_not equal(date)
     end
     
@@ -114,5 +168,78 @@ describe 'Date/DateTime' do
     end
     
   end
+  
+  describe 'uncertain/approximate hash' do
+    
+    it 'is 0 by default' do
+      Date.new().send(:ua_hash).should == 0
+    end
+    
+    it 'is 8 for approximate year' do
+      Date.new.approximate!(:year).send(:ua_hash).should == 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
+				xmas.values.should == [2011,12,24]
+			end
+
+			it 'returns [2011,12] for christmas with month precision' do
+				xmas.month_precision!.values.should == [2011,12]
+			end
+
+			it 'returns [2011] for christmas with year precision' do
+				xmas.year_precision!.values.should == [2011]
+			end
+			
+		end
+		
+		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)
+			end
+
+			it '2009-12-24 should be less than 2011-12' do
+				Date.new(2009,12,24).should < Date.edtf('2011-12')
+			end
+
+			it '2009-12-24 should be less than 2011' do
+				Date.new(2009,12,24).should < Date.edtf('2011')
+			end
+			
+			
+		end
+		
+		describe '#==' do
+			
+			it "xmas and new year's eve are not equal" do
+				xmas.should_not == 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!
+			end
+
+			it "xmas and january 24 are not equal using month percision" do
+				xmas.month_precision!.should_not == 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!
+			end
+			
+		end
+		
+	end
+	
     
 end