chronic 0.2.3 → 0.3.0

data/lib/chronic/repeaters/repeater_year.rb

@@ -1,8 +1,14 @@
 class Chronic::RepeaterYear < Chronic::Repeater #:nodoc:
-  
+  YEAR_SECONDS =  31536000  # 365 * 24 * 60 * 60
+
+  def initialize(type)
+    super
+    @current_year_start = nil
+  end
+
   def next(pointer)
     super
-    
+
     if !@current_year_start
       case pointer
       when :future
@@ -14,13 +20,13 @@ class Chronic::RepeaterYear < Chronic::Repeater #:nodoc:
       diff = pointer == :future ? 1 : -1
       @current_year_start = Time.construct(@current_year_start.year + diff)
     end
-    
+
     Chronic::Span.new(@current_year_start, Time.construct(@current_year_start.year + 1))
   end
-  
+
   def this(pointer = :future)
     super
-    
+
     case pointer
     when :future
       this_year_start = Time.construct(@now.year, @now.month, @now.day) + Chronic::RepeaterDay::DAY_SECONDS
@@ -32,27 +38,27 @@ class Chronic::RepeaterYear < Chronic::Repeater #:nodoc:
       this_year_start = Time.construct(@now.year, 1, 1)
       this_year_end = Time.construct(@now.year + 1, 1, 1)
     end
-    
+
     Chronic::Span.new(this_year_start, this_year_end)
   end
-  
+
   def offset(span, amount, pointer)
     direction = pointer == :future ? 1 : -1
-    
+
     sb = span.begin
     new_begin = Time.construct(sb.year + (amount * direction), sb.month, sb.day, sb.hour, sb.min, sb.sec)
-    
+
     se = span.end
     new_end = Time.construct(se.year + (amount * direction), se.month, se.day, se.hour, se.min, se.sec)
-    
+
     Chronic::Span.new(new_begin, new_end)
   end
-  
+
   def width
     (365 * 24 * 60 * 60)
   end
-  
+
   def to_s
     super << '-year'
   end
-end
+end

data/lib/chronic/scalar.rb

@@ -11,7 +11,7 @@ module Chronic
       end
       tokens
     end
-  
+
     def self.scan_for_scalars(token, post_token)
       if token.word =~ /^\d*$/
         unless post_token && %w{am pm morning afternoon evening night}.include?(post_token)
@@ -20,55 +20,57 @@ module Chronic
       end
       return nil
     end
-    
+
     def self.scan_for_days(token, post_token)
       if token.word =~ /^\d\d?$/
-        unless token.word.to_i > 31 || (post_token && %w{am pm morning afternoon evening night}.include?(post_token))
-          return ScalarDay.new(token.word.to_i)
+        toi = token.word.to_i
+        unless toi > 31 || toi < 1 || (post_token && %w{am pm morning afternoon evening night}.include?(post_token.word))
+          return ScalarDay.new(toi)
         end
       end
       return nil
     end
-    
+
     def self.scan_for_months(token, post_token)
       if token.word =~ /^\d\d?$/
-        unless token.word.to_i > 12 || (post_token && %w{am pm morning afternoon evening night}.include?(post_token))
-          return ScalarMonth.new(token.word.to_i)
+        toi = token.word.to_i
+        unless toi > 12 || toi < 1 || (post_token && %w{am pm morning afternoon evening night}.include?(post_token.word))
+          return ScalarMonth.new(toi)
         end
       end
       return nil
     end
-    
+
     def self.scan_for_years(token, post_token)
       if token.word =~ /^([1-9]\d)?\d\d?$/
-        unless post_token && %w{am pm morning afternoon evening night}.include?(post_token)
+        unless post_token && %w{am pm morning afternoon evening night}.include?(post_token.word)
           return ScalarYear.new(token.word.to_i)
         end
       end
       return nil
     end
-    
+
     def to_s
       'scalar'
     end
   end
-  
+
   class ScalarDay < Scalar #:nodoc:
     def to_s
       super << '-day-' << @type.to_s
     end
   end
-  
+
   class ScalarMonth < Scalar #:nodoc:
     def to_s
       super << '-month-' << @type.to_s
     end
   end
-  
+
   class ScalarYear < Scalar #:nodoc:
     def to_s
       super << '-year-' << @type.to_s
     end
   end
 
-end
+end

data/lib/chronic/separator.rb

@@ -7,10 +7,11 @@ module Chronic
         if t = self.scan_for_slash_or_dash(tokens[i]) then tokens[i].tag(t); next end
         if t = self.scan_for_at(tokens[i]) then tokens[i].tag(t); next end
         if t = self.scan_for_in(tokens[i]) then tokens[i].tag(t); next end
+        if t = self.scan_for_on(tokens[i]) then tokens[i].tag(t); next end
       end
       tokens
     end
-    
+
     def self.scan_for_commas(token)
       scanner = {/^,$/ => :comma}
       scanner.keys.each do |scanner_item|
@@ -18,7 +19,7 @@ module Chronic
       end
       return nil
     end
-    
+
     def self.scan_for_slash_or_dash(token)
       scanner = {/^-$/ => :dash,
                  /^\/$/ => :slash}
@@ -27,7 +28,7 @@ module Chronic
       end
       return nil
     end
-    
+
     def self.scan_for_at(token)
       scanner = {/^(at|@)$/ => :at}
       scanner.keys.each do |scanner_item|
@@ -35,7 +36,7 @@ module Chronic
       end
       return nil
     end
-    
+
     def self.scan_for_in(token)
       scanner = {/^in$/ => :in}
       scanner.keys.each do |scanner_item|
@@ -43,34 +44,48 @@ module Chronic
       end
       return nil
     end
-    
+
+    def self.scan_for_on(token)
+      scanner = {/^on$/ => :on}
+      scanner.keys.each do |scanner_item|
+        return SeparatorOn.new(scanner[scanner_item]) if scanner_item =~ token.word
+      end
+      return nil
+    end
+
     def to_s
       'separator'
     end
   end
-  
+
   class SeparatorComma < Separator #:nodoc:
     def to_s
       super << '-comma'
     end
   end
-  
+
   class SeparatorSlashOrDash < Separator #:nodoc:
     def to_s
       super << '-slashordash-' << @type.to_s
     end
   end
-  
+
   class SeparatorAt < Separator #:nodoc:
     def to_s
       super << '-at'
     end
   end
-  
+
   class SeparatorIn < Separator #:nodoc:
     def to_s
       super << '-in'
     end
   end
 
-end
+  class SeparatorOn < Separator #:nodoc:
+    def to_s
+      super << '-on'
+    end
+  end
+
+end

data/lib/chronic/time_zone.rb

@@ -1,5 +1,5 @@
 module Chronic
-  class TimeZone < Tag #:nodoc:    
+  class TimeZone < Tag #:nodoc:
     def self.scan(tokens)
       tokens.each_index do |i|
         if t = self.scan_for_all(tokens[i]) then tokens[i].tag(t); next end
@@ -8,7 +8,8 @@ module Chronic
     end
 
     def self.scan_for_all(token)
-      scanner = {/[PMCE][DS]T/i => :tz}
+      scanner = {/[PMCE][DS]T/i => :tz,
+                 /(tzminus)?\d{4}/ => :tz}
       scanner.keys.each do |scanner_item|
         return self.new(scanner[scanner_item]) if scanner_item =~ token.word
       end
@@ -19,4 +20,4 @@ module Chronic
       'timezone'
     end
   end
-end
+end

data/test/helper.rb

@@ -0,0 +1,7 @@
+require 'test/unit'
+
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift(File.join(dir, '..', 'lib'))
+$LOAD_PATH.unshift(dir)
+
+require 'chronic'

data/test/test_Chronic.rb

@@ -1,50 +1,49 @@
-require 'chronic'
-require 'test/unit'
+require File.join(File.dirname(__FILE__), *%w[helper])
 
 class TestChronic < Test::Unit::TestCase
-  
+
   def setup
     # Wed Aug 16 14:00:00 UTC 2006
     @now = Time.local(2006, 8, 16, 14, 0, 0, 0)
   end
-  
+
   def test_post_normalize_am_pm_aliases
     # affect wanted patterns
-    
+
     tokens = [Chronic::Token.new("5:00"), Chronic::Token.new("morning")]
     tokens[0].tag(Chronic::RepeaterTime.new("5:00"))
     tokens[1].tag(Chronic::RepeaterDayPortion.new(:morning))
-    
+
     assert_equal :morning, tokens[1].tags[0].type
-    
+
     tokens = Chronic.dealias_and_disambiguate_times(tokens, {})
-    
+
     assert_equal :am, tokens[1].tags[0].type
     assert_equal 2, tokens.size
-    
+
     # don't affect unwanted patterns
-    
+
     tokens = [Chronic::Token.new("friday"), Chronic::Token.new("morning")]
     tokens[0].tag(Chronic::RepeaterDayName.new(:friday))
     tokens[1].tag(Chronic::RepeaterDayPortion.new(:morning))
-    
+
     assert_equal :morning, tokens[1].tags[0].type
-    
+
     tokens = Chronic.dealias_and_disambiguate_times(tokens, {})
-    
+
     assert_equal :morning, tokens[1].tags[0].type
     assert_equal 2, tokens.size
   end
-  
+
   def test_guess
     span = Chronic::Span.new(Time.local(2006, 8, 16, 0), Time.local(2006, 8, 17, 0))
     assert_equal Time.local(2006, 8, 16, 12), Chronic.guess(span)
-    
+
     span = Chronic::Span.new(Time.local(2006, 8, 16, 0), Time.local(2006, 8, 17, 0, 0, 1))
     assert_equal Time.local(2006, 8, 16, 12), Chronic.guess(span)
-    
+
     span = Chronic::Span.new(Time.local(2006, 11), Time.local(2006, 12))
     assert_equal Time.local(2006, 11, 16), Chronic.guess(span)
   end
-  
-end
+
+end

data/test/test_DaylightSavings.rb

@@ -0,0 +1,118 @@
+require File.join(File.dirname(__FILE__), *%w[helper])
+
+class TestDaylightSavings < Test::Unit::TestCase
+
+  def setup
+    @begin_daylight_savings = Time.local(2008, 3, 9, 5, 0, 0, 0)
+    @end_daylight_savings = Time.local(2008, 11, 2, 5, 0, 0, 0)
+  end
+
+  def test_begin_past
+    # ambiguous - resolve to last night
+    t = Chronic::RepeaterTime.new('900')
+    t.start = @begin_daylight_savings
+    assert_equal Time.local(2008, 3, 8, 21), t.next(:past).begin
+
+    # ambiguous - resolve to this afternoon
+    t = Chronic::RepeaterTime.new('900')
+    t.start = Time.local(2008, 3, 9, 22, 0, 0, 0)
+    assert_equal Time.local(2008, 3, 9, 21), t.next(:past).begin
+
+    # ambiguous - resolve to this morning
+    t = Chronic::RepeaterTime.new('400')
+    t.start = @begin_daylight_savings
+    assert_equal Time.local(2008, 3, 9, 4), t.next(:past).begin
+
+    # unambiguous - resolve to today
+    t = Chronic::RepeaterTime.new('0400')
+    t.start = @begin_daylight_savings
+    assert_equal Time.local(2008, 3, 9, 4), t.next(:past).begin
+
+    # unambiguous - resolve to yesterday
+    t = Chronic::RepeaterTime.new('1300')
+    t.start = @begin_daylight_savings
+    assert_equal Time.local(2008, 3, 8, 13), t.next(:past).begin
+  end
+
+  def test_begin_future
+    # ambiguous - resolve to this morning
+    t = Chronic::RepeaterTime.new('900')
+    t.start = @begin_daylight_savings
+    assert_equal Time.local(2008, 3, 9, 9), t.next(:future).begin
+
+    # ambiguous - resolve to this afternoon
+    t = Chronic::RepeaterTime.new('900')
+    t.start = Time.local(2008, 3, 9, 13, 0, 0, 0)
+    assert_equal Time.local(2008, 3, 9, 21), t.next(:future).begin
+
+    # ambiguous - resolve to tomorrow
+    t = Chronic::RepeaterTime.new('900')
+    t.start = Time.local(2008, 3, 9, 22, 0, 0, 0)
+    assert_equal Time.local(2008, 3, 10, 9), t.next(:future).begin
+
+    # unambiguous - resolve to today
+    t = Chronic::RepeaterTime.new('0900')
+    t.start = @begin_daylight_savings
+    assert_equal Time.local(2008, 3, 9, 9), t.next(:future).begin
+
+    # unambiguous - resolve to tomorrow
+    t = Chronic::RepeaterTime.new('0400')
+    t.start = @begin_daylight_savings
+    assert_equal Time.local(2008, 3, 10, 4), t.next(:future).begin
+  end
+
+  def test_end_past
+    # ambiguous - resolve to last night
+    t = Chronic::RepeaterTime.new('900')
+    t.start = @end_daylight_savings
+    assert_equal Time.local(2008, 11, 1, 21), t.next(:past).begin
+
+    # ambiguous - resolve to this afternoon
+    t = Chronic::RepeaterTime.new('900')
+    t.start = Time.local(2008, 11, 2, 22, 0, 0, 0)
+    assert_equal Time.local(2008, 11, 2, 21), t.next(:past).begin
+
+    # ambiguous - resolve to this morning
+    t = Chronic::RepeaterTime.new('400')
+    t.start = @end_daylight_savings
+    assert_equal Time.local(2008, 11, 2, 4), t.next(:past).begin
+
+    # unambiguous - resolve to today
+    t = Chronic::RepeaterTime.new('0400')
+    t.start = @end_daylight_savings
+    assert_equal Time.local(2008, 11, 2, 4), t.next(:past).begin
+
+    # unambiguous - resolve to yesterday
+    t = Chronic::RepeaterTime.new('1300')
+    t.start = @end_daylight_savings
+    assert_equal Time.local(2008, 11, 1, 13), t.next(:past).begin
+  end
+
+  def test_end_future
+    # ambiguous - resolve to this morning
+    t = Chronic::RepeaterTime.new('900')
+    t.start = @end_daylight_savings
+    assert_equal Time.local(2008, 11, 2, 9), t.next(:future).begin
+
+    # ambiguous - resolve to this afternoon
+    t = Chronic::RepeaterTime.new('900')
+    t.start = Time.local(2008, 11, 2, 13, 0, 0, 0)
+    assert_equal Time.local(2008, 11, 2, 21), t.next(:future).begin
+
+    # ambiguous - resolve to tomorrow
+    t = Chronic::RepeaterTime.new('900')
+    t.start = Time.local(2008, 11, 2, 22, 0, 0, 0)
+    assert_equal Time.local(2008, 11, 3, 9), t.next(:future).begin
+
+    # unambiguous - resolve to today
+    t = Chronic::RepeaterTime.new('0900')
+    t.start = @end_daylight_savings
+    assert_equal Time.local(2008, 11, 2, 9), t.next(:future).begin
+
+    # unambiguous - resolve to tomorrow
+    t = Chronic::RepeaterTime.new('0400')
+    t.start = @end_daylight_savings
+    assert_equal Time.local(2008, 11, 3, 4), t.next(:future).begin
+  end
+
+end