chronic 0.1.5 → 0.2.0

data/History.txt

@@ -1,3 +1,12 @@
+= 0.2.0 2007-03-20
+
+* fixed time overflow issue
+* implemented numerizer, allowing the use of number words (e.g. five weeks ago) (shalev)
+
+= 0.1.6 2006-01-15
+
+* added 'weekend' support (eventualbuddha)
+
 = 0.1.5 2006-12-20
 
 * fixed 'aug 20' returning next year if current month is august

data/Manifest.txt

@@ -26,10 +26,11 @@ lib/chronic/repeaters/repeater_weekend.rb
 lib/chronic/repeaters/repeater_year.rb
 lib/chronic/scalar.rb
 lib/chronic/separator.rb
-test/parse_numbers.rb
+lib/numerizer/numerizer.rb
 test/suite.rb
 test/test_Chronic.rb
 test/test_Handler.rb
+test/test_Numerizer.rb
 test/test_RepeaterDayName.rb
 test/test_RepeaterFortnight.rb
 test/test_RepeaterHour.rb
@@ -37,6 +38,7 @@ test/test_RepeaterMonth.rb
 test/test_RepeaterMonthName.rb
 test/test_RepeaterTime.rb
 test/test_RepeaterWeek.rb
+test/test_RepeaterWeekend.rb
 test/test_RepeaterYear.rb
 test/test_Span.rb
 test/test_Token.rb

data/Rakefile

@@ -10,6 +10,8 @@ Hoe.new('chronic', Chronic::VERSION) do |p|
   p.description = p.paragraphs_of('README.txt', 2).join("\n\n")
   p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
   p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+  p.need_tar = false
+  p.extra_deps = []
 end
 
 # vim: syntax=Ruby

data/lib/chronic/chronic.rb

@@ -101,6 +101,7 @@ module Chronic
     # ordinals (third => 3rd)
     def pre_normalize(text) #:nodoc:
       normalized_text = text.to_s.downcase
+      normalized_text = numericize_numbers(normalized_text)
       normalized_text.gsub!(/['"\.]/, '')
       normalized_text.gsub!(/([\/\-\,\@])/) { ' ' + $1 + ' ' }
       normalized_text.gsub!(/\btoday\b/, 'this day')
@@ -118,15 +119,12 @@ module Chronic
       normalized_text.gsub!(/\btonight\b/, 'this night')
       normalized_text.gsub!(/(?=\w)([ap]m|oclock)\b/, ' \1')
       normalized_text.gsub!(/\b(hence|after|from)\b/, 'future')
-      normalized_text.gsub!(/\ba\b/, '1')
-      normalized_text.gsub!(/\s+/, ' ')
-      normalized_text = numericize_numbers(normalized_text)
       normalized_text = numericize_ordinals(normalized_text)
     end
   
     # Convert number words to numbers (three => 3)
     def numericize_numbers(text) #:nodoc:
-      text
+      Numerizer.numerize(text)
     end
   
     # Convert ordinal words to numeric ordinals (third => 3rd)

data/lib/chronic/handlers.rb

@@ -214,17 +214,19 @@ module Chronic
     def handle_s_r_p(tokens, options) #:nodoc:
       repeater = tokens[1].get_tag(Repeater)
             
-      span = 
-      case true
-      when [RepeaterYear, RepeaterSeason, RepeaterSeasonName, RepeaterMonth, RepeaterMonthName, RepeaterFortnight, RepeaterWeek].include?(repeater.class)
-        self.parse("this hour", :guess => false, :now => @now)
-      when [RepeaterWeekend, RepeaterDay, RepeaterDayName, RepeaterDayPortion, RepeaterHour].include?(repeater.class)
-        self.parse("this minute", :guess => false, :now => @now)
-      when [RepeaterMinute, RepeaterSecond].include?(repeater.class)
-        self.parse("this second", :guess => false, :now => @now)
-      else
-        raise(ChronicPain, "Invalid repeater: #{repeater.class}")
-      end
+      # span = 
+      # case true
+      # when [RepeaterYear, RepeaterSeason, RepeaterSeasonName, RepeaterMonth, RepeaterMonthName, RepeaterFortnight, RepeaterWeek].include?(repeater.class)
+      #   self.parse("this hour", :guess => false, :now => @now)
+      # when [RepeaterWeekend, RepeaterDay, RepeaterDayName, RepeaterDayPortion, RepeaterHour].include?(repeater.class)
+      #   self.parse("this minute", :guess => false, :now => @now)
+      # when [RepeaterMinute, RepeaterSecond].include?(repeater.class)
+      #   self.parse("this second", :guess => false, :now => @now)
+      # else
+      #   raise(ChronicPain, "Invalid repeater: #{repeater.class}")
+      # end
+      
+      span = self.parse("this second", :guess => false, :now => @now)
       
       self.handle_srp(tokens, span, options)
     end

data/lib/chronic/pointer.rb

@@ -10,9 +10,9 @@ module Chronic
     end
   
     def self.scan_for_all(token)
-      scanner = {/past/ => :past,
-                 /future/ => :future,
-                 /in/ => :future}
+      scanner = {/\bpast\b/ => :past,
+                 /\bfuture\b/ => :future,
+                 /\bin\b/ => :future}
       scanner.keys.each do |scanner_item|
         return self.new(scanner[scanner_item]) if scanner_item =~ token.word
       end

data/lib/chronic/repeater.rb

@@ -72,7 +72,7 @@ class Chronic::Repeater < Chronic::Tag #:nodoc:
                /^months?$/ => :month,
                /^fortnights?$/ => :fortnight,
                /^weeks?$/ => :week,
-               /^weekends?$/ => :weekends,
+               /^weekends?$/ => :weekend,
                /^days?$/ => :day,
                /^hours?$/ => :hour,
                /^minutes?$/ => :minute,
@@ -104,7 +104,7 @@ class Chronic::Repeater < Chronic::Tag #:nodoc:
   end
   
   def this(pointer)
-    !@now.nil? || raise("Start point must be set before calling #next")
+    !@now.nil? || raise("Start point must be set before calling #this")
     [:future, :past, :none].include?(pointer) || raise("First argument 'pointer' must be one of :past, :future, :none")
   end
   

data/lib/chronic/repeaters/repeater_hour.rb

@@ -24,8 +24,8 @@ class Chronic::RepeaterHour < Chronic::Repeater #:nodoc:
     
     case pointer
     when :future
-      hour_start = Time.local(@now.year, @now.month, @now.day, @now.hour, @now.min + 1)
-      hour_end = Time.local(@now.year, @now.month, @now.day, @now.hour + 1)
+      hour_start = Time.construct(@now.year, @now.month, @now.day, @now.hour, @now.min + 1)
+      hour_end = Time.construct(@now.year, @now.month, @now.day, @now.hour + 1)
     when :past
       hour_start = Time.local(@now.year, @now.month, @now.day, @now.hour)
       hour_end = Time.local(@now.year, @now.month, @now.day, @now.hour, @now.min)

data/lib/chronic/repeaters/repeater_weekend.rb

@@ -1,6 +1,55 @@
 class Chronic::RepeaterWeekend < Chronic::Repeater #:nodoc:
   WEEKEND_SECONDS = 172_800 # (2 * 24 * 60 * 60)
   
+  def next(pointer)
+    super
+    
+    if !@current_week_start
+      case pointer
+      when :future
+        saturday_repeater = Chronic::RepeaterDayName.new(:saturday)
+        saturday_repeater.start = @now
+        next_saturday_span = saturday_repeater.next(:future)
+        @current_week_start = next_saturday_span.begin
+      when :past
+        saturday_repeater = Chronic::RepeaterDayName.new(:saturday)
+        saturday_repeater.start = (@now + Chronic::RepeaterDay::DAY_SECONDS)
+        last_saturday_span = saturday_repeater.next(:past)
+        @current_week_start = last_saturday_span.begin
+      end
+    else
+      direction = pointer == :future ? 1 : -1
+      @current_week_start += direction * Chronic::RepeaterWeek::WEEK_SECONDS
+    end
+    
+    Chronic::Span.new(@current_week_start, @current_week_start + WEEKEND_SECONDS)
+  end
+  
+  def this(pointer = :future)
+    super
+    
+    case pointer
+    when :future, :none
+      saturday_repeater = Chronic::RepeaterDayName.new(:saturday)
+      saturday_repeater.start = @now
+      this_saturday_span = saturday_repeater.this(:future)
+      Chronic::Span.new(this_saturday_span.begin, this_saturday_span.begin + WEEKEND_SECONDS)
+    when :past
+      saturday_repeater = Chronic::RepeaterDayName.new(:saturday)
+      saturday_repeater.start = @now
+      last_saturday_span = saturday_repeater.this(:past)
+      Chronic::Span.new(last_saturday_span.begin, last_saturday_span.begin + WEEKEND_SECONDS)
+    end
+  end
+  
+  def offset(span, amount, pointer)
+    direction = pointer == :future ? 1 : -1
+    weekend = Chronic::RepeaterWeekend.new(:weekend)
+    weekend.start = span.begin
+    start = weekend.next(pointer).begin + (amount - 1) * direction * Chronic::RepeaterWeek::WEEK_SECONDS
+    Chronic::Span.new(start, start + (span.end - span.begin))
+  end
+  
   def width
     WEEKEND_SECONDS
   end

data/lib/chronic.rb

@@ -7,6 +7,8 @@
 #
 #=============================================================================
 
+$:.unshift File.dirname(__FILE__)     # For use/testing when no gem is installed
+
 require 'chronic/chronic'
 require 'chronic/handlers'
 
@@ -33,8 +35,10 @@ require 'chronic/scalar'
 require 'chronic/ordinal'
 require 'chronic/separator'
 
+require 'numerizer/numerizer'
+
 module Chronic
-  VERSION = "0.1.5"
+  VERSION = "0.2.0"
   
   def self.debug; false; end
 end
@@ -44,4 +48,25 @@ alias p_orig p
 def p(val)
   p_orig val
   puts
+end
+
+class Time
+  def self.construct(year, month = 1, day = 1, hour = 0, minute = 0, second = 0)
+    if second >= 60
+      minute += second / 60
+      second = second % 60
+    end
+    
+    if minute >= 60
+      hour += minute / 60
+      minute = minute % 60
+    end
+    
+    if hour >= 24
+      day += hour / 24
+      hour = hour % 24
+    end
+    
+    Time.local(year, month, day, hour, minute, second)
+  end
 end

data/lib/numerizer/numerizer.rb

@@ -0,0 +1,103 @@
+require 'strscan'
+
+class Numerizer
+
+  DIRECT_NUMS = [
+                  ['eleven', '11'],
+                  ['twelve', '12'],
+                  ['thirteen', '13'],
+                  ['fourteen', '14'],
+                  ['fifteen', '15'],
+                  ['sixteen', '16'],
+                  ['seventeen', '17'],
+                  ['eighteen', '18'],
+                  ['nineteen', '19'],
+                  ['ninteen', '19'], # Common mis-spelling
+                  ['zero', '0'],
+                  ['one', '1'],
+                  ['two', '2'],
+                  ['three', '3'],
+                  ['four(\W|$)', '4\1'],  # The weird regex is so that it matches four but not fourty
+                  ['five', '5'],
+                  ['six(\W|$)', '6\1'],
+                  ['seven(\W|$)', '7\1'],
+                  ['eight(\W|$)', '8\1'],
+                  ['nine(\W|$)', '9\1'],
+                  ['ten', '10'],
+                  ['\ba[\b^$]', '1'] # doesn't make sense for an 'a' at the end to be a 1
+                ]
+
+  TEN_PREFIXES = [ ['twenty', 20],
+                    ['thirty', 30],
+                    ['fourty', 40],
+                    ['fifty', 50],
+                    ['sixty', 60],
+                    ['seventy', 70],
+                    ['eighty', 80],
+                    ['ninety', 90]
+                  ]
+
+  BIG_PREFIXES = [ ['hundred', 100],
+                    ['thousand', 1000],
+                    ['million', 1_000_000],
+                    ['billion', 1_000_000_000],
+                    ['trillion', 1_000_000_000_000],
+                  ]
+
+class << self
+  def numerize(string)
+    string = string.dup
+  
+    # preprocess
+    string.gsub!(/ +|([^\d])-([^d])/, '\1 \2') # will mutilate hyphenated-words but shouldn't matter for date extraction
+    string.gsub!(/a half/, 'haAlf') # take the 'a' out so it doesn't turn into a 1, save the half for the end
+
+    # easy/direct replacements
+  
+    DIRECT_NUMS.each do |dn|
+      string.gsub!(/#{dn[0]}/i, dn[1])
+    end
+
+    # ten, twenty, etc.
+
+    TEN_PREFIXES.each do |tp|
+      string.gsub!(/(?:#{tp[0]})( *\d(?=[^\d]|$))*/i) { (tp[1] + $1.to_i).to_s }
+    end
+
+    # hundreds, thousands, millions, etc.
+
+    BIG_PREFIXES.each do |bp|
+      string.gsub!(/(\d*) *#{bp[0]}/i) { (bp[1] * $1.to_i).to_s}
+      andition(string)
+      #combine_numbers(string) # Should to be more efficient way to do this
+    end
+
+    # fractional addition
+    # I'm not combining this with the previous block as using float addition complicates the strings
+    # (with extraneous .0's and such )
+    string.gsub!(/(\d+)(?: | and |-)*haAlf/i) { ($1.to_f + 0.5).to_s }
+
+    string
+  end
+
+private
+  def andition(string)
+    sc = StringScanner.new(string)
+    while(sc.scan_until(/(\d+)( | and )(\d+)(?=[^\w]|$)/i))
+      if sc[2] =~ /and/ || sc[1].size > sc[3].size
+        string[(sc.pos - sc.matched_size)..(sc.pos-1)] = (sc[1].to_i + sc[3].to_i).to_s
+        sc.reset
+      end
+    end
+  end
+
+#  def combine_numbers(string)
+#    sc = StringScanner.new(string)
+#    while(sc.scan_until(/(\d+)(?: | and |-)(\d+)(?=[^\w]|$)/i))
+#      string[(sc.pos - sc.matched_size)..(sc.pos-1)] = (sc[1].to_i + sc[2].to_i).to_s
+#      sc.reset
+#    end
+#  end
+
+end
+end

data/test/{parse_numbers.rb → test_Numerizer.rb}

@@ -1,11 +1,10 @@
-__END__
-
 require 'test/unit'
+require 'chronic'
 
 class ParseNumbersTest < Test::Unit::TestCase
 
-  def test_parse
-    strings = {1 => 'one',
+  def test_straight_parsing
+    strings = { 1 => 'one',
                5 => 'five',
                10 => 'ten',
                11 => 'eleven',
@@ -24,7 +23,7 @@ class ParseNumbersTest < Test::Unit::TestCase
                100 => 'a hundred',
                100 => 'one hundred',
                150 => 'one hundred and fifty',
-               150 => 'one fifty',
+            #   150 => 'one fifty',
                200 => 'two-hundred',
                500 => '5 hundred',
                999 => 'nine hundred and ninety nine',
@@ -40,11 +39,10 @@ class ParseNumbersTest < Test::Unit::TestCase
                1_000_000 => 'one million',
                1_250_007 => 'one million two hundred fifty thousand and seven',
                1_000_000_000 => 'one billion',
-               1_000_000_001 => 'one billion and one'}
+               1_000_000_001 => 'one billion and one' }
                
     strings.keys.sort.each do |key|
-      assert_equal key, JW::NumberMagick.convert(strings[key])
+      assert_equal key, Numerizer.numerize(strings[key]).to_i
     end
   end
-  
 end

data/test/test_RepeaterWeekend.rb

@@ -0,0 +1,75 @@
+require 'chronic'
+require 'test/unit'
+
+class TestRepeaterWeekend < Test::Unit::TestCase
+  
+  def setup
+    # Wed Aug 16 14:00:00 2006
+    @now = Time.local(2006, 8, 16, 14, 0, 0, 0)
+  end
+  
+  def test_next_future
+    weekend = Chronic::RepeaterWeekend.new(:weekend)
+    weekend.start = @now
+    
+    next_weekend = weekend.next(:future)
+    assert_equal Time.local(2006, 8, 19), next_weekend.begin
+    assert_equal Time.local(2006, 8, 21), next_weekend.end
+  end
+  
+  def test_next_past
+    weekend = Chronic::RepeaterWeekend.new(:weekend)
+    weekend.start = @now
+    
+    next_weekend = weekend.next(:past)
+    assert_equal Time.local(2006, 8, 12), next_weekend.begin
+    assert_equal Time.local(2006, 8, 14), next_weekend.end
+  end
+  
+  def test_this_future
+    weekend = Chronic::RepeaterWeekend.new(:weekend)
+    weekend.start = @now
+    
+    next_weekend = weekend.this(:future)
+    assert_equal Time.local(2006, 8, 19), next_weekend.begin
+    assert_equal Time.local(2006, 8, 21), next_weekend.end
+  end
+  
+  def test_this_past
+    weekend = Chronic::RepeaterWeekend.new(:weekend)
+    weekend.start = @now
+    
+    next_weekend = weekend.this(:past)
+    assert_equal Time.local(2006, 8, 12), next_weekend.begin
+    assert_equal Time.local(2006, 8, 14), next_weekend.end
+  end
+  
+  def test_this_none
+    weekend = Chronic::RepeaterWeekend.new(:weekend)
+    weekend.start = @now
+    
+    next_weekend = weekend.this(:future)
+    assert_equal Time.local(2006, 8, 19), next_weekend.begin
+    assert_equal Time.local(2006, 8, 21), next_weekend.end
+  end
+  
+  def test_offset
+    span = Chronic::Span.new(@now, @now + 1)
+    
+    offset_span = Chronic::RepeaterWeekend.new(:weekend).offset(span, 3, :future)
+    
+    assert_equal Time.local(2006, 9, 2), offset_span.begin
+    assert_equal Time.local(2006, 9, 2, 0, 0, 1), offset_span.end
+    
+    offset_span = Chronic::RepeaterWeekend.new(:weekend).offset(span, 1, :past)
+    
+    assert_equal Time.local(2006, 8, 12), offset_span.begin
+    assert_equal Time.local(2006, 8, 12, 0, 0, 1), offset_span.end
+    
+    offset_span = Chronic::RepeaterWeekend.new(:weekend).offset(span, 0, :future)
+    
+    assert_equal Time.local(2006, 8, 12), offset_span.begin
+    assert_equal Time.local(2006, 8, 12, 0, 0, 1), offset_span.end
+  end
+  
+end

data/test/test_parsing.rb

@@ -2,496 +2,535 @@ require 'chronic'
 require 'test/unit'
 
 class TestParsing < Test::Unit::TestCase
+  # Wed Aug 16 14:00:00 UTC 2006
+  TIME_2006_08_16_14_00_00 = Time.local(2006, 8, 16, 14, 0, 0, 0)
   
   def setup
-    # Wed Aug 16 14:00:00 UTC 2006
-    @time_2006_08_16_14_00_00 = Time.local(2006, 8, 16, 14, 0, 0, 0)
-    @time_2006_08_16_03_00_00 = Time.local(2006, 8, 16, 3, 0, 0, 0)
+    @time_2006_08_16_14_00_00 = TIME_2006_08_16_14_00_00
   end
   
-  def test__parse_guess_dates
+  def test_parse_guess_dates
     # rm_sd
 
-    time = Chronic.parse("may 27", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("may 27")
     assert_equal Time.local(2007, 5, 27, 12), time
     
-    time = Chronic.parse("may 28", :now => @time_2006_08_16_14_00_00, :context => :past)
+    time = parse_now("may 28", :context => :past)
     assert_equal Time.local(2006, 5, 28, 12), time
     
-    time = Chronic.parse("may 28 5pm", :now => @time_2006_08_16_14_00_00, :context => :past)
+    time = parse_now("may 28 5pm", :context => :past)
     assert_equal Time.local(2006, 5, 28, 17), time
     
-    time = Chronic.parse("may 28 at 5pm", :now => @time_2006_08_16_14_00_00, :context => :past)
+    time = parse_now("may 28 at 5pm", :context => :past)
     assert_equal Time.local(2006, 5, 28, 17), time
     
-    time = Chronic.parse("may 28 at 5:32.19pm", :now => @time_2006_08_16_14_00_00, :context => :past)
+    time = parse_now("may 28 at 5:32.19pm", :context => :past)
     assert_equal Time.local(2006, 5, 28, 17, 32, 19), time
     
     # rm_od
     
-    time = Chronic.parse("may 27th", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("may 27th")
     assert_equal Time.local(2007, 5, 27, 12), time
     
-    time = Chronic.parse("may 27th", :now => @time_2006_08_16_14_00_00, :context => :past)
+    time = parse_now("may 27th", :context => :past)
     assert_equal Time.local(2006, 5, 27, 12), time
     
-    time = Chronic.parse("may 27th 5:00 pm", :now => @time_2006_08_16_14_00_00, :context => :past)
+    time = parse_now("may 27th 5:00 pm", :context => :past)
     assert_equal Time.local(2006, 5, 27, 17), time
     
-    time = Chronic.parse("may 27th at 5pm", :now => @time_2006_08_16_14_00_00, :context => :past)
+    time = parse_now("may 27th at 5pm", :context => :past)
     assert_equal Time.local(2006, 5, 27, 17), time
     
-    time = Chronic.parse("may 27th at 5", :now => @time_2006_08_16_14_00_00, :ambiguous_time_range => :none)
+    time = parse_now("may 27th at 5", :ambiguous_time_range => :none)
     assert_equal Time.local(2007, 5, 27, 5), time
     
     # rm_sy
     
-    time = Chronic.parse("June 1979", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("June 1979")
     assert_equal Time.local(1979, 6, 16, 0), time
     
-    time = Chronic.parse("dec 79", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("dec 79")
     assert_equal Time.local(1979, 12, 16, 12), time
     
     # rm_sd_sy
     
-    time = Chronic.parse("jan 3 2010", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("jan 3 2010")
     assert_equal Time.local(2010, 1, 3, 12), time
     
-    time = Chronic.parse("jan 3 2010 midnight", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("jan 3 2010 midnight")
     assert_equal Time.local(2010, 1, 4, 0), time
     
-    time = Chronic.parse("jan 3 2010 at midnight", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("jan 3 2010 at midnight")
     assert_equal Time.local(2010, 1, 4, 0), time
     
-    time = Chronic.parse("jan 3 2010 at 4", :now => @time_2006_08_16_14_00_00, :ambiguous_time_range => :none)
+    time = parse_now("jan 3 2010 at 4", :ambiguous_time_range => :none)
     assert_equal Time.local(2010, 1, 3, 4), time
     
-    #time = Chronic.parse("January 12, '00", :now => @time_2006_08_16_14_00_00)
+    #time = parse_now("January 12, '00")
     #assert_equal Time.local(2000, 1, 12, 12), time
     
-    time = Chronic.parse("may 27 79", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("may 27 79")
     assert_equal Time.local(1979, 5, 27, 12), time
     
-    time = Chronic.parse("may 27 79 4:30", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("may 27 79 4:30")
     assert_equal Time.local(1979, 5, 27, 16, 30), time
     
-    time = Chronic.parse("may 27 79 at 4:30", :now => @time_2006_08_16_14_00_00, :ambiguous_time_range => :none)
+    time = parse_now("may 27 79 at 4:30", :ambiguous_time_range => :none)
     assert_equal Time.local(1979, 5, 27, 4, 30), time
     
     # sd_rm_sy
 
-    time = Chronic.parse("3 jan 2010", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("3 jan 2010")
     assert_equal Time.local(2010, 1, 3, 12), time
     
-    time = Chronic.parse("3 jan 2010 4pm", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("3 jan 2010 4pm")
     assert_equal Time.local(2010, 1, 3, 16), time
     
     # sm_sd_sy
     
-    time = Chronic.parse("5/27/1979", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("5/27/1979")
     assert_equal Time.local(1979, 5, 27, 12), time
     
-    time = Chronic.parse("5/27/1979 4am", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("5/27/1979 4am")
     assert_equal Time.local(1979, 5, 27, 4), time
     
     # sd_sm_sy
     
-    time = Chronic.parse("27/5/1979", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("27/5/1979")
     assert_equal Time.local(1979, 5, 27, 12), time
     
-    time = Chronic.parse("27/5/1979 @ 0700", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("27/5/1979 @ 0700")
     assert_equal Time.local(1979, 5, 27, 7), time
     
     # sm_sy
     
-    time = Chronic.parse("05/06", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("05/06")
     assert_equal Time.local(2006, 5, 16, 12), time
     
-    time = Chronic.parse("12/06", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("12/06")
     assert_equal Time.local(2006, 12, 16, 12), time
     
-    time = Chronic.parse("13/06", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("13/06")
     assert_equal nil, time
     
     # sy_sm_sd
     
-    time = Chronic.parse("2000-1-1", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("2000-1-1")
     assert_equal Time.local(2000, 1, 1, 12), time
     
-    time = Chronic.parse("2006-08-20", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("2006-08-20")
     assert_equal Time.local(2006, 8, 20, 12), time
     
-    time = Chronic.parse("2006-08-20 7pm", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("2006-08-20 7pm")
     assert_equal Time.local(2006, 8, 20, 19), time
     
-    time = Chronic.parse("2006-08-20 03:00", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("2006-08-20 03:00")
     assert_equal Time.local(2006, 8, 20, 3), time
     
-    time = Chronic.parse("2006-08-20 03:30:30", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("2006-08-20 03:30:30")
     assert_equal Time.local(2006, 8, 20, 3, 30, 30), time
     
-    time = Chronic.parse("2006-08-20 15:30:30", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("2006-08-20 15:30:30")
     assert_equal Time.local(2006, 8, 20, 15, 30, 30), time
     
-    time = Chronic.parse("2006-08-20 15:30.30", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("2006-08-20 15:30.30")
     assert_equal Time.local(2006, 8, 20, 15, 30, 30), time
     
     # rm_sd_rt
     
-    #time = Chronic.parse("jan 5 13:00", :now => @time_2006_08_16_14_00_00)
+    #time = parse_now("jan 5 13:00")
     #assert_equal Time.local(2007, 1, 5, 13), time
     
     # due to limitations of the Time class, these don't work
     
-    time = Chronic.parse("may 40", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("may 40")
     assert_equal nil, time
     
-    time = Chronic.parse("may 27 40", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("may 27 40")
     assert_equal nil, time
     
-    time = Chronic.parse("1800-08-20", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("1800-08-20")
     assert_equal nil, time
   end
 
   def test_parse_guess_r
-    time = Chronic.parse("friday", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("friday")
     assert_equal Time.local(2006, 8, 18, 12), time
     
-    time = Chronic.parse("5", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("5")
     assert_equal Time.local(2006, 8, 16, 17), time
     
-    time = Chronic.parse("5", :now => @time_2006_08_16_03_00_00, :ambiguous_time_range => :none)
+    time = Chronic.parse("5", :now => Time.local(2006, 8, 16, 3, 0, 0, 0), :ambiguous_time_range => :none)
     assert_equal Time.local(2006, 8, 16, 5), time
     
-    time = Chronic.parse("13:00", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("13:00")
     assert_equal Time.local(2006, 8, 17, 13), time
     
-    time = Chronic.parse("13:45", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("13:45")
     assert_equal Time.local(2006, 8, 17, 13, 45), time
     
-    time = Chronic.parse("november", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("november")
     assert_equal Time.local(2006, 11, 16), time
   end
   
   def test_parse_guess_rr
-    time = Chronic.parse("friday 13:00", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("friday 13:00")
     assert_equal Time.local(2006, 8, 18, 13), time
     
-    time = Chronic.parse("monday 4:00", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("monday 4:00")
     assert_equal Time.local(2006, 8, 21, 16), time
     
-    time = Chronic.parse("sat 4:00", :now => @time_2006_08_16_14_00_00, :ambiguous_time_range => :none)
+    time = parse_now("sat 4:00", :ambiguous_time_range => :none)
     assert_equal Time.local(2006, 8, 19, 4), time
     
-    time = Chronic.parse("sunday 4:20", :now => @time_2006_08_16_14_00_00, :ambiguous_time_range => :none)
+    time = parse_now("sunday 4:20", :ambiguous_time_range => :none)
     assert_equal Time.local(2006, 8, 20, 4, 20), time
     
-    time = Chronic.parse("4 pm", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("4 pm")
     assert_equal Time.local(2006, 8, 16, 16), time
     
-    time = Chronic.parse("4 am", :now => @time_2006_08_16_14_00_00, :ambiguous_time_range => :none)
+    time = parse_now("4 am", :ambiguous_time_range => :none)
     assert_equal Time.local(2006, 8, 16, 4), time
     
-    time = Chronic.parse("4:00 in the morning", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("4:00 in the morning")
     assert_equal Time.local(2006, 8, 16, 4), time
     
-    time = Chronic.parse("november 4", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("november 4")
     assert_equal Time.local(2006, 11, 4, 12), time
     
-    time = Chronic.parse("aug 24", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("aug 24")
     assert_equal Time.local(2006, 8, 24, 12), time
   end
   
   def test_parse_guess_rrr
-    time = Chronic.parse("friday 1 pm", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("friday 1 pm")
     assert_equal Time.local(2006, 8, 18, 13), time
     
-    time = Chronic.parse("friday 11 at night", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("friday 11 at night")
     assert_equal Time.local(2006, 8, 18, 23), time
     
-    time = Chronic.parse("friday 11 in the evening", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("friday 11 in the evening")
     assert_equal Time.local(2006, 8, 18, 23), time
     
-    time = Chronic.parse("sunday 6am", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("sunday 6am")
     assert_equal Time.local(2006, 8, 20, 6), time
   end
   
   def test_parse_guess_gr
     # year
     
-    time = Chronic.parse("this year", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("this year")
     assert_equal Time.local(2006, 10, 24, 12, 30), time
     
-    time = Chronic.parse("this year", :now => @time_2006_08_16_14_00_00, :context => :past)
+    time = parse_now("this year", :context => :past)
     assert_equal Time.local(2006, 4, 24, 12, 30), time
     
     # month
     
-    time = Chronic.parse("this month", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("this month")
     assert_equal Time.local(2006, 8, 24, 12), time
     
-    time = Chronic.parse("this month", :now => @time_2006_08_16_14_00_00, :context => :past)
+    time = parse_now("this month", :context => :past)
     assert_equal Time.local(2006, 8, 8, 12), time
     
     # month name
     
-    time = Chronic.parse("last november", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("last november")
     assert_equal Time.local(2005, 11, 16), time
     
     # fortnight
     
-    time = Chronic.parse("this fortnight", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("this fortnight")
     assert_equal Time.local(2006, 8, 21, 19, 30), time
     
-    time = Chronic.parse("this fortnight", :now => @time_2006_08_16_14_00_00, :context => :past)
+    time = parse_now("this fortnight", :context => :past)
     assert_equal Time.local(2006, 8, 14, 19), time
     
     # week
     
-    time = Chronic.parse("this week", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("this week")
     assert_equal Time.local(2006, 8, 18, 7, 30), time
     
-    time = Chronic.parse("this week", :now => @time_2006_08_16_14_00_00, :context => :past)
+    time = parse_now("this week", :context => :past)
     assert_equal Time.local(2006, 8, 14, 19), time
     
+    # weekend
+    
+    time = parse_now("this weekend")
+    assert_equal Time.local(2006, 8, 20), time
+    
+    time = parse_now("this weekend", :context => :past)
+    assert_equal Time.local(2006, 8, 13), time
+    
+    time = parse_now("last weekend")
+    assert_equal Time.local(2006, 8, 13), time
+    
     # day
     
-    time = Chronic.parse("this day", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("this day")
     assert_equal Time.local(2006, 8, 16, 19, 30), time
     
-    time = Chronic.parse("this day", :now => @time_2006_08_16_14_00_00, :context => :past)
+    time = parse_now("this day", :context => :past)
     assert_equal Time.local(2006, 8, 16, 7), time
     
-    time = Chronic.parse("today", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("today")
     assert_equal Time.local(2006, 8, 16, 19, 30), time
     
-    time = Chronic.parse("yesterday", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("yesterday")
     assert_equal Time.local(2006, 8, 15, 12), time
     
-    time = Chronic.parse("tomorrow", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("tomorrow")
     assert_equal Time.local(2006, 8, 17, 12), time
     
     # day name
     
-    time = Chronic.parse("this tuesday", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("this tuesday")
     assert_equal Time.local(2006, 8, 22, 12), time
     
-    time = Chronic.parse("next tuesday", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("next tuesday")
     assert_equal Time.local(2006, 8, 22, 12), time
     
-    time = Chronic.parse("last tuesday", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("last tuesday")
     assert_equal Time.local(2006, 8, 15, 12), time
     
-    time = Chronic.parse("this wed", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("this wed")
     assert_equal Time.local(2006, 8, 23, 12), time
     
-    time = Chronic.parse("next wed", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("next wed")
     assert_equal Time.local(2006, 8, 23, 12), time
     
-    time = Chronic.parse("last wed", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("last wed")
     assert_equal Time.local(2006, 8, 9, 12), time
     
     # day portion
     
-    time = Chronic.parse("this morning", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("this morning")
     assert_equal Time.local(2006, 8, 16, 9), time
     
-    time = Chronic.parse("tonight", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("tonight")
     assert_equal Time.local(2006, 8, 16, 22), time
     
     # second
     
-    time = Chronic.parse("this second", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("this second")
     assert_equal Time.local(2006, 8, 16, 14), time
     
-    time = Chronic.parse("this second", :now => @time_2006_08_16_14_00_00, :context => :past)
+    time = parse_now("this second", :context => :past)
     assert_equal Time.local(2006, 8, 16, 14), time
     
-    time = Chronic.parse("next second", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("next second")
     assert_equal Time.local(2006, 8, 16, 14, 0, 1), time
     
-    time = Chronic.parse("last second", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("last second")
     assert_equal Time.local(2006, 8, 16, 13, 59, 59), time
   end
   
   def test_parse_guess_grr    
-    time = Chronic.parse("yesterday at 4:00", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("yesterday at 4:00")
     assert_equal Time.local(2006, 8, 15, 16), time
     
-    time = Chronic.parse("today at 9:00", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("today at 9:00")
     assert_equal Time.local(2006, 8, 16, 9), time
     
-    time = Chronic.parse("today at 2100", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("today at 2100")
     assert_equal Time.local(2006, 8, 16, 21), time
     
-    time = Chronic.parse("this day at 0900", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("this day at 0900")
     assert_equal Time.local(2006, 8, 16, 9), time
     
-    time = Chronic.parse("tomorrow at 0900", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("tomorrow at 0900")
     assert_equal Time.local(2006, 8, 17, 9), time
     
-    time = Chronic.parse("yesterday at 4:00", :now => @time_2006_08_16_14_00_00, :ambiguous_time_range => :none)
+    time = parse_now("yesterday at 4:00", :ambiguous_time_range => :none)
     assert_equal Time.local(2006, 8, 15, 4), time
     
-    time = Chronic.parse("last friday at 4:00", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("last friday at 4:00")
     assert_equal Time.local(2006, 8, 11, 16), time
     
-    time = Chronic.parse("next wed 4:00", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("next wed 4:00")
     assert_equal Time.local(2006, 8, 23, 16), time
     
-    time = Chronic.parse("yesterday afternoon", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("yesterday afternoon")
     assert_equal Time.local(2006, 8, 15, 15), time
     
-    time = Chronic.parse("last week tuesday", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("last week tuesday")
     assert_equal Time.local(2006, 8, 8, 12), time
   end
   
   def test_parse_guess_grrr
-    time = Chronic.parse("today at 6:00pm", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("today at 6:00pm")
     assert_equal Time.local(2006, 8, 16, 18), time
     
-    time = Chronic.parse("today at 6:00am", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("today at 6:00am")
     assert_equal Time.local(2006, 8, 16, 6), time
     
-    time = Chronic.parse("this day 1800", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("this day 1800")
     assert_equal Time.local(2006, 8, 16, 18), time
     
-    time = Chronic.parse("yesterday at 4:00pm", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("yesterday at 4:00pm")
     assert_equal Time.local(2006, 8, 15, 16), time
   end
   
   def test_parse_guess_rgr
-    time = Chronic.parse("afternoon yesterday", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("afternoon yesterday")
     assert_equal Time.local(2006, 8, 15, 15), time
     
-    time = Chronic.parse("tuesday last week", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("tuesday last week")
     assert_equal Time.local(2006, 8, 8, 12), time
   end
   
   def test_parse_guess_s_r_p
     # past
     
-    time = Chronic.parse("3 years ago", :now => @time_2006_08_16_14_00_00)
-    assert_equal Time.local(2003, 8, 16, 14, 30, 30), time
+    time = parse_now("3 years ago")
+    assert_equal Time.local(2003, 8, 16, 14), time
     
-    time = Chronic.parse("1 month ago", :now => @time_2006_08_16_14_00_00)
-    assert_equal Time.local(2006, 7, 16, 14, 30, 30), time
+    time = parse_now("1 month ago")
+    assert_equal Time.local(2006, 7, 16, 14), time
     
-    time = Chronic.parse("1 fortnight ago", :now => @time_2006_08_16_14_00_00)
-    assert_equal Time.local(2006, 8, 2, 14, 30, 30), time
+    time = parse_now("1 fortnight ago")
+    assert_equal Time.local(2006, 8, 2, 14), time
     
-    time = Chronic.parse("2 fortnights ago", :now => @time_2006_08_16_14_00_00)
-    assert_equal Time.local(2006, 7, 19, 14, 30, 30), time
+    time = parse_now("2 fortnights ago")
+    assert_equal Time.local(2006, 7, 19, 14), time
     
-    time = Chronic.parse("3 weeks ago", :now => @time_2006_08_16_14_00_00)
-    assert_equal Time.local(2006, 7, 26, 14, 30, 30), time
+    time = parse_now("3 weeks ago")
+    assert_equal Time.local(2006, 7, 26, 14), time
     
-    time = Chronic.parse("3 days ago", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("2 weekends ago")
+    assert_equal Time.local(2006, 8, 5), time
+    
+    time = parse_now("3 days ago")
     assert_equal Time.local(2006, 8, 13, 14), time
     
-    #time = Chronic.parse("1 monday ago", :now => @time_2006_08_16_14_00_00)
+    #time = parse_now("1 monday ago")
     #assert_equal Time.local(2006, 8, 14, 12), time
     
-    time = Chronic.parse("5 mornings ago", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("5 mornings ago")
     assert_equal Time.local(2006, 8, 12, 9), time
     
-    time = Chronic.parse("7 hours ago", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("7 hours ago")
     assert_equal Time.local(2006, 8, 16, 7), time
     
-    time = Chronic.parse("3 minutes ago", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("3 minutes ago")
     assert_equal Time.local(2006, 8, 16, 13, 57), time
     
-    time = Chronic.parse("20 seconds before now", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("20 seconds before now")
     assert_equal Time.local(2006, 8, 16, 13, 59, 40), time
 
     # future
     
-    time = Chronic.parse("3 years from now", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("3 years from now")
     assert_equal Time.local(2009, 8, 16, 14, 0, 0), time
     
-    time = Chronic.parse("6 months hence", :now => @time_2006_08_16_14_00_00)
-    assert_equal Time.local(2007, 2, 16, 14, 30, 30), time
+    time = parse_now("6 months hence")
+    assert_equal Time.local(2007, 2, 16, 14), time
     
-    time = Chronic.parse("3 fortnights hence", :now => @time_2006_08_16_14_00_00)
-    assert_equal Time.local(2006, 9, 27, 14, 30, 30), time
+    time = parse_now("3 fortnights hence")
+    assert_equal Time.local(2006, 9, 27, 14), time
     
-    time = Chronic.parse("1 week from now", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("1 week from now")
     assert_equal Time.local(2006, 8, 23, 14, 0, 0), time
     
-    time = Chronic.parse("1 day hence", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("1 weekend from now")
+    assert_equal Time.local(2006, 8, 19), time
+    
+    time = parse_now("2 weekends from now")
+    assert_equal Time.local(2006, 8, 26), time
+    
+    time = parse_now("1 day hence")
     assert_equal Time.local(2006, 8, 17, 14), time
     
-    time = Chronic.parse("5 mornings hence", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("5 mornings hence")
     assert_equal Time.local(2006, 8, 21, 9), time
     
-    time = Chronic.parse("1 hour from now", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("1 hour from now")
     assert_equal Time.local(2006, 8, 16, 15), time
     
-    time = Chronic.parse("20 minutes hence", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("20 minutes hence")
     assert_equal Time.local(2006, 8, 16, 14, 20), time
     
-    time = Chronic.parse("20 seconds from now", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("20 seconds from now")
     assert_equal Time.local(2006, 8, 16, 14, 0, 20), time
+    
+    time = Chronic.parse("2 months ago", :now => Time.parse("2007-03-07 23:30"))
+    assert_equal Time.local(2007, 1, 7, 23, 30), time
   end
   
   def test_parse_guess_p_s_r
-    time = Chronic.parse("in 3 hours", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("in 3 hours")
     assert_equal Time.local(2006, 8, 16, 17), time
   end
   
   def test_parse_guess_s_r_p_a
     # past
     
-    time = Chronic.parse("3 years ago tomorrow", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("3 years ago tomorrow")
     assert_equal Time.local(2003, 8, 17, 12), time
     
-    time = Chronic.parse("3 years ago this friday", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("3 years ago this friday")
     assert_equal Time.local(2003, 8, 18, 12), time
     
-    time = Chronic.parse("3 months ago saturday at 5:00 pm", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("3 months ago saturday at 5:00 pm")
     assert_equal Time.local(2006, 5, 19, 17), time
     
-    time = Chronic.parse("2 days from this second", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("2 days from this second")
     assert_equal Time.local(2006, 8, 18, 14), time
     
-    time = Chronic.parse("7 hours before tomorrow at midnight", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("7 hours before tomorrow at midnight")
     assert_equal Time.local(2006, 8, 17, 17), time
     
     # future
   end
   
   def test_parse_guess_o_r_s_r
-    time = Chronic.parse("3rd wednesday in november", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("3rd wednesday in november")
     assert_equal Time.local(2006, 11, 15, 12), time
     
-    time = Chronic.parse("10th wednesday in november", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("10th wednesday in november")
     assert_equal nil, time
   end
   
   def test_parse_guess_o_r_g_r
-    time = Chronic.parse("3rd month next year", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("3rd month next year")
     assert_equal Time.local(2007, 3, 16, 12, 30), time
     
-    time = Chronic.parse("3rd thursday this september", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("3rd thursday this september")
     assert_equal Time.local(2006, 9, 21, 12), time
     
-    time = Chronic.parse("4th day last week", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("4th day last week")
     assert_equal Time.local(2006, 8, 9, 12), time
   end
   
   def test_parse_guess_nonsense
-    time = Chronic.parse("some stupid nonsense", :now => @time_2006_08_16_14_00_00)
+    time = parse_now("some stupid nonsense")
     assert_equal nil, time
   end
   
   def test_parse_span
-    span = Chronic.parse("friday", :now => @time_2006_08_16_14_00_00, :guess => false)
+    span = parse_now("friday", :guess => false)
     assert_equal Time.local(2006, 8, 18), span.begin
     assert_equal Time.local(2006, 8, 19), span.end
     
-    span = Chronic.parse("november", :now => @time_2006_08_16_14_00_00, :guess => false)
+    span = parse_now("november", :guess => false)
     assert_equal Time.local(2006, 11), span.begin
     assert_equal Time.local(2006, 12), span.end
+    
+    span = Chronic.parse("weekend" , :now => @time_2006_08_16_14_00_00, :guess => false)
+    assert_equal Time.local(2006, 8, 19), span.begin
+    assert_equal Time.local(2006, 8, 21), span.end
+  end
+  
+  def test_parse_words
+    assert_equal parse_now("33 days from now"), parse_now("thirty-three days from now")
+    assert_equal parse_now("2867532 seconds from now"), parse_now("two million eight hundred and sixty seven thousand five hundred and thirty two seconds from now")
+    assert_equal parse_now("may 10th"), parse_now("may tenth")
+  end
+  
+  def test_parse_only_complete_pointers
+    assert_equal parse_now("eat pasty buns today at 2pm"), @time_2006_08_16_14_00_00
+    assert_equal parse_now("futuristically speaking today at 2pm"), @time_2006_08_16_14_00_00
+    assert_equal parse_now("meeting today at 2pm"), @time_2006_08_16_14_00_00
   end
   
   def test_argument_validation
@@ -504,4 +543,8 @@ class TestParsing < Test::Unit::TestCase
     end
   end
   
+  private
+  def parse_now(string, options={})
+    Chronic.parse(string, {:now => TIME_2006_08_16_14_00_00 }.merge(options))
+  end
 end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.11
+rubygems_version: 0.9.0
 specification_version: 1
 name: chronic
 version: !ruby/object:Gem::Version 
-  version: 0.1.5
-date: 2006-12-21 00:00:00 -08:00
+  version: 0.2.0
+date: 2007-03-20 00:00:00 -07:00
 summary: A natural language date parser
 require_paths: 
 - lib
@@ -25,6 +25,7 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
 platform: ruby
 signing_key: 
 cert_chain: 
+post_install_message: 
 authors: 
 - Ryan Davis
 files: 
@@ -56,10 +57,11 @@ files:
 - lib/chronic/repeaters/repeater_year.rb
 - lib/chronic/scalar.rb
 - lib/chronic/separator.rb
-- test/parse_numbers.rb
+- lib/numerizer/numerizer.rb
 - test/suite.rb
 - test/test_Chronic.rb
 - test/test_Handler.rb
+- test/test_Numerizer.rb
 - test/test_RepeaterDayName.rb
 - test/test_RepeaterFortnight.rb
 - test/test_RepeaterHour.rb
@@ -67,6 +69,7 @@ files:
 - test/test_RepeaterMonthName.rb
 - test/test_RepeaterTime.rb
 - test/test_RepeaterWeek.rb
+- test/test_RepeaterWeekend.rb
 - test/test_RepeaterYear.rb
 - test/test_Span.rb
 - test/test_Token.rb
@@ -74,6 +77,7 @@ files:
 test_files: 
 - test/test_Chronic.rb
 - test/test_Handler.rb
+- test/test_Numerizer.rb
 - test/test_parsing.rb
 - test/test_RepeaterDayName.rb
 - test/test_RepeaterFortnight.rb
@@ -82,6 +86,7 @@ test_files:
 - test/test_RepeaterMonthName.rb
 - test/test_RepeaterTime.rb
 - test/test_RepeaterWeek.rb
+- test/test_RepeaterWeekend.rb
 - test/test_RepeaterYear.rb
 - test/test_Span.rb
 - test/test_Token.rb
@@ -103,5 +108,5 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.1.6
+        version: 1.2.0
     version: