chronic 0.3.0 → 0.4.0

data/lib/chronic/scalar.rb

@@ -1,53 +1,61 @@
 module Chronic
 
   class Scalar < Tag #:nodoc:
-    def self.scan(tokens)
+    DAY_PORTIONS = %w( am pm morning afternoon evening night )
+
+    def self.scan(tokens, options)
       # for each token
       tokens.each_index do |i|
-        if t = self.scan_for_scalars(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
-        if t = self.scan_for_days(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
-        if t = self.scan_for_months(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
-        if t = self.scan_for_years(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
+        if t = scan_for_scalars(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
+        if t = scan_for_days(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
+        if t = scan_for_months(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
+        if t = scan_for_years(tokens[i], tokens[i + 1], options) then tokens[i].tag(t) end
       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)
+        unless post_token && DAY_PORTIONS.include?(post_token.word)
           return Scalar.new(token.word.to_i)
         end
       end
-      return nil
     end
 
     def self.scan_for_days(token, post_token)
       if token.word =~ /^\d\d?$/
         toi = token.word.to_i
-        unless toi > 31 || toi < 1 || (post_token && %w{am pm morning afternoon evening night}.include?(post_token.word))
+        unless toi > 31 || toi < 1 || (post_token && DAY_PORTIONS.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?$/
         toi = token.word.to_i
-        unless toi > 12 || toi < 1 || (post_token && %w{am pm morning afternoon evening night}.include?(post_token.word))
+        unless toi > 12 || toi < 1 || (post_token && DAY_PORTIONS.include?(post_token.word))
           return ScalarMonth.new(toi)
         end
       end
-      return nil
     end
 
-    def self.scan_for_years(token, post_token)
+    def self.scan_for_years(token, post_token, options)
       if token.word =~ /^([1-9]\d)?\d\d?$/
-        unless post_token && %w{am pm morning afternoon evening night}.include?(post_token.word)
-          return ScalarYear.new(token.word.to_i)
+        unless post_token && DAY_PORTIONS.include?(post_token.word)
+          year = make_year(token.word.to_i, options[:ambiguous_year_future_bias])
+          return ScalarYear.new(year.to_i)
         end
       end
-      return nil
+    end
+
+    # Build a year from a 2 digit suffix
+    def self.make_year(year, bias)
+      return year if year.to_s.size > 2
+      start_year = Chronic.time_class.now.year - bias
+      century = (start_year / 100) * 100
+      full_year = century + year
+      full_year += 100 if full_year < start_year
+      full_year
     end
 
     def to_s

data/lib/chronic/separator.rb

@@ -1,56 +1,38 @@
 module Chronic
 
   class Separator < Tag #:nodoc:
-    def self.scan(tokens)
+    def self.scan(tokens, options)
       tokens.each_index do |i|
-        if t = self.scan_for_commas(tokens[i]) then tokens[i].tag(t); next end
-        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
+        if t = scan_for_commas(tokens[i]) then tokens[i].tag(t); next end
+        if t = scan_for_slash_or_dash(tokens[i]) then tokens[i].tag(t); next end
+        if t = scan_for_at(tokens[i]) then tokens[i].tag(t); next end
+        if t = scan_for_in(tokens[i]) then tokens[i].tag(t); next end
+        if t = 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|
-        return SeparatorComma.new(scanner[scanner_item]) if scanner_item =~ token.word
-      end
-      return nil
+      scan_for token, SeparatorComma, { /^,$/ => :comma }
     end
 
     def self.scan_for_slash_or_dash(token)
-      scanner = {/^-$/ => :dash,
-                 /^\/$/ => :slash}
-      scanner.keys.each do |scanner_item|
-        return SeparatorSlashOrDash.new(scanner[scanner_item]) if scanner_item =~ token.word
-      end
-      return nil
+      scan_for token, SeparatorSlashOrDash,
+      {
+        /^-$/ => :dash,
+        /^\/$/ => :slash
+      }
     end
 
     def self.scan_for_at(token)
-      scanner = {/^(at|@)$/ => :at}
-      scanner.keys.each do |scanner_item|
-        return SeparatorAt.new(scanner[scanner_item]) if scanner_item =~ token.word
-      end
-      return nil
+      scan_for token, SeparatorAt, { /^(at|@)$/ => :at }
     end
 
     def self.scan_for_in(token)
-      scanner = {/^in$/ => :in}
-      scanner.keys.each do |scanner_item|
-        return SeparatorIn.new(scanner[scanner_item]) if scanner_item =~ token.word
-      end
-      return nil
+      scan_for token, SeparatorIn, { /^in$/ => :in }
     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
+      scan_for token, SeparatorOn, { /^on$/ => :on }
     end
 
     def to_s

data/lib/chronic/span.rb

@@ -0,0 +1,31 @@
+module Chronic
+  # A Span represents a range of time. Since this class extends
+  # Range, you can use #begin and #end to get the beginning and
+  # ending times of the span (they will be of class Time)
+  class Span < Range
+    # Returns the width of this span in seconds
+    def width
+      (self.end - self.begin).to_i
+    end
+
+    # Add a number of seconds to this span, returning the
+    # resulting Span
+    def +(seconds)
+      Span.new(self.begin + seconds, self.end + seconds)
+    end
+
+    # Subtract a number of seconds to this span, returning the
+    # resulting Span
+    def -(seconds)
+      self + -seconds
+    end
+
+    # Prints this span in a nice fashion
+    def to_s
+      '(' << self.begin.to_s << '..' << self.end.to_s << ')'
+    end
+
+    alias :cover? :include? unless RUBY_VERSION =~ /^1.9/
+
+  end
+end

data/lib/chronic/tag.rb

@@ -0,0 +1,26 @@
+module Chronic
+  # Tokens are tagged with subclassed instances of this class when
+  # they match specific criteria
+  class Tag #:nodoc:
+    attr_accessor :type
+
+    def initialize(type)
+      @type = type
+    end
+
+    def start=(s)
+      @now = s
+    end
+
+    class << self
+      private
+
+      def scan_for(token, klass, items={})
+        items.each do |item, symbol|
+          return klass.new(symbol) if item =~ token.word
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/chronic/time_zone.rb

@@ -1,19 +1,17 @@
 module Chronic
   class TimeZone < Tag #:nodoc:
-    def self.scan(tokens)
+    def self.scan(tokens, options)
       tokens.each_index do |i|
-        if t = self.scan_for_all(tokens[i]) then tokens[i].tag(t); next end
+        if t = scan_for_all(tokens[i]) then tokens[i].tag(t); next end
       end
-      tokens
     end
 
     def self.scan_for_all(token)
-      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
-      return nil
+      scan_for token, self,
+      {
+        /[PMCE][DS]T/i => :tz,
+        /(tzminus)?\d{4}/ => :tz
+      }
     end
 
     def to_s

data/lib/chronic/token.rb

@@ -0,0 +1,35 @@
+module Chronic
+  class Token #:nodoc:
+    attr_accessor :word, :tags
+
+    def initialize(word)
+      @word = word
+      @tags = []
+    end
+
+    # Tag this token with the specified tag
+    def tag(new_tag)
+      @tags << new_tag
+    end
+
+    # Remove all tags of the given class
+    def untag(tag_class)
+      @tags.delete_if { |m| m.kind_of? tag_class }
+    end
+
+    # Return true if this token has any tags
+    def tagged?
+      @tags.size > 0
+    end
+
+    # Return the Tag that matches the given class
+    def get_tag(tag_class)
+      @tags.find { |m| m.kind_of? tag_class }
+    end
+
+    # Print this Token in a pretty way
+    def to_s
+      @word << '(' << @tags.join(', ') << ') '
+    end
+  end
+end

data/test/helper.rb

@@ -1,7 +1,6 @@
-require 'test/unit'
+unless defined? Chronic
+  $:.unshift File.expand_path('../../lib')
+  require 'chronic'
+end
 
-dir = File.dirname(File.expand_path(__FILE__))
-$LOAD_PATH.unshift(File.join(dir, '..', 'lib'))
-$LOAD_PATH.unshift(dir)
-
-require 'chronic'
+require 'test/unit'

data/test/test_Chronic.rb

@@ -7,6 +7,11 @@ class TestChronic < Test::Unit::TestCase
     @now = Time.local(2006, 8, 16, 14, 0, 0, 0)
   end
 
+  def test_pre_normalize_numerized_string
+    string = 'two and a half years'
+    assert_equal Chronic::Numerizer.numerize(string), Chronic.pre_normalize(string)
+  end
+
   def test_post_normalize_am_pm_aliases
     # affect wanted patterns
 

data/test/test_Numerizer.rb

@@ -3,49 +3,70 @@ require File.join(File.dirname(__FILE__), *%w[helper])
 class ParseNumbersTest < Test::Unit::TestCase
 
   def test_straight_parsing
-    strings = { 1 => 'one',
-               5 => 'five',
-               10 => 'ten',
-               11 => 'eleven',
-               12 => 'twelve',
-               13 => 'thirteen',
-               14 => 'fourteen',
-               15 => 'fifteen',
-               16 => 'sixteen',
-               17 => 'seventeen',
-               18 => 'eighteen',
-               19 => 'nineteen',
-               20 => 'twenty',
-               27 => 'twenty seven',
-               31 => 'thirty-one',
-               59 => 'fifty nine',
-               100 => 'a hundred',
-               100 => 'one hundred',
-               150 => 'one hundred and fifty',
-               # 150 => 'one fifty',
-               200 => 'two-hundred',
-               500 => '5 hundred',
-               999 => 'nine hundred and ninety nine',
-               1_000 => 'one thousand',
-               1_200 => 'twelve hundred',
-               1_200 => 'one thousand two hundred',
-               17_000 => 'seventeen thousand',
-               21_473 => 'twentyone-thousand-four-hundred-and-seventy-three',
-               74_002 => 'seventy four thousand and two',
-               99_999 => 'ninety nine thousand nine hundred ninety nine',
-               100_000 => '100 thousand',
-               250_000 => 'two hundred fifty thousand',
-               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' }
+    strings = {
+      'one' => 1,
+      'five' => 5,
+      'ten' => 10,
+      'eleven' => 11,
+      'twelve' => 12,
+      'thirteen' => 13,
+      'fourteen' => 14,
+      'fifteen' => 15,
+      'sixteen' => 16,
+      'seventeen' => 17,
+      'eighteen' => 18,
+      'nineteen' => 19,
+      'twenty' => 20,
+      'twenty seven' => 27,
+      'thirty-one' => 31,
+      'thirty-seven' => 37,
+      'thirty seven' => 37,
+      'fifty nine' => 59,
+      'forty two' => 42,
+      'fourty two' => 42,
+      # 'a hundred' => 100,
+      'one hundred' => 100,
+      'one hundred and fifty' => 150,
+      # 'one fifty' => 150,
+      'two-hundred' => 200,
+      '5 hundred' => 500,
+      'nine hundred and ninety nine' => 999,
+      'one thousand' => 1000,
+      'twelve hundred' => 1200,
+      'one thousand two hundred' => 1_200,
+      'seventeen thousand' => 17_000,
+      'twentyone-thousand-four-hundred-and-seventy-three' => 21_473,
+      'seventy four thousand and two' => 74_002,
+      'ninety nine thousand nine hundred ninety nine' => 99_999,
+      '100 thousand' => 100_000,
+      'two hundred fifty thousand' => 250_000,
+      'one million' => 1_000_000,
+      'one million two hundred fifty thousand and seven' => 1_250_007,
+      'one billion' => 1_000_000_000,
+      'one billion and one' => 1_000_000_001}
 
-    strings.keys.sort.each do |key|
-      assert_equal key, Numerizer.numerize(strings[key]).to_i
+    strings.each do |key, val|
+      assert_equal val, Chronic::Numerizer.numerize(key).to_i
+    end
+  end
+
+  def test_ordinal_strings
+    {
+      'first' => '1st',
+      'second' => 'second',
+      'second day' => '2nd day',
+      'second of may' => '2nd of may',
+      'fifth' => '5th',
+      'twenty third' => '23rd',
+      'first day month two' => '1st day month 2'
+    }.each do |key, val|
+      # Use pre_normalize here instead of Numerizer directly because
+      # pre_normalize deals with parsing 'second' appropriately
+      assert_equal val, Chronic.pre_normalize(key)
     end
   end
 
   def test_edges
-    assert_equal "27 Oct 2006 7:30am", Numerizer.numerize("27 Oct 2006 7:30am")
+    assert_equal "27 Oct 2006 7:30am", Chronic::Numerizer.numerize("27 Oct 2006 7:30am")
   end
 end

data/test/test_RepeaterHour.rb

@@ -45,6 +45,10 @@ class TestRepeaterHour < Test::Unit::TestCase
     this_hour = hours.this(:past)
     assert_equal Time.local(2006, 8, 16, 14), this_hour.begin
     assert_equal Time.local(2006, 8, 16, 14, 30), this_hour.end
+
+    this_hour = hours.this(:none)
+    assert_equal Time.local(2006, 8, 16, 14), this_hour.begin
+    assert_equal Time.local(2006, 8, 16, 15), this_hour.end
   end
 
   def test_offset

data/test/test_parsing.rb

@@ -26,6 +26,20 @@ class TestParsing < Test::Unit::TestCase
     time = parse_now("may 28 at 5:32.19pm", :context => :past)
     assert_equal Time.local(2006, 5, 28, 17, 32, 19), time
 
+    # rm_sd for current month
+
+    time = parse_now("aug 3")
+    assert_equal Time.local(2006, 8, 3, 12), time
+
+    time = parse_now("aug 3", :context => :past)
+    assert_equal Time.local(2006, 8, 3, 12), time
+
+    time = parse_now("aug 20")
+    assert_equal Time.local(2006, 8, 20, 12), time
+
+    time = parse_now("aug 20", :context => :future)
+    assert_equal Time.local(2006, 8, 20, 12), time
+
     # rm_sd_on
 
     time = parse_now("5pm on may 28")
@@ -59,6 +73,9 @@ class TestParsing < Test::Unit::TestCase
     time = parse_now("5:00 pm may 27th", :context => :past)
     assert_equal Time.local(2006, 5, 27, 17), time
 
+    time = parse_now("05:00 pm may 27th", :context => :past)
+    assert_equal Time.local(2006, 5, 27, 17), time
+
     time = parse_now("5pm on may 27th", :context => :past)
     assert_equal Time.local(2006, 5, 27, 17), time
 
@@ -73,8 +90,46 @@ class TestParsing < Test::Unit::TestCase
     time = parse_now("dec 79")
     assert_equal Time.local(1979, 12, 16, 12), time
 
+    # rm_od_sy
+
+    time = parse_now("November 18th 2010")
+    assert_equal Time.local(2010, 11, 18, 12), time
+
+    time = parse_now("November 18th, 2010")
+    assert_equal Time.local(2010, 11, 18, 12), time
+
+    time = parse_now("November 18th 2010 midnight")
+    assert_equal Time.local(2010, 11, 19, 0), time
+
+    time = parse_now("November 18th 2010 at midnight")
+    assert_equal Time.local(2010, 11, 19, 0), time
+
+    time = parse_now("November 18th 2010 at 4")
+    assert_equal Time.local(2010, 11, 18, 16), time
+
+    time = parse_now("November 18th 2010 at 4", :ambiguous_time_range => :none)
+    assert_equal Time.local(2010, 11, 18, 4), time
+
+    time = parse_now("March 30th, 1979")
+    assert_equal Time.local(1979, 3, 30, 12), time
+
+    time = parse_now("March 30th 79")
+    assert_equal Time.local(1979, 3, 30, 12), time
+
+    time = parse_now("March 30th 79 4:30")
+    assert_equal Time.local(1979, 3, 30, 16, 30), time
+
+    time = parse_now("March 30th 79 at 4:30", :ambiguous_time_range => :none)
+    assert_equal Time.local(1979, 3, 30, 4, 30), time
+
     # rm_sd_sy
 
+    time = parse_now("November 18, 2010")
+    assert_equal Time.local(2010, 11, 18, 12), time
+
+    time = parse_now("February 14, 2004")
+    assert_equal Time.local(2004, 2, 14, 12), time
+
     time = parse_now("jan 3 2010")
     assert_equal Time.local(2010, 1, 3, 12), time
 
@@ -170,7 +225,7 @@ class TestParsing < Test::Unit::TestCase
 
     now = Time.now
     time = parse_now(now.to_s)
-    assert_equal now.to_s, time.to_s
+    # assert_equal now.to_s, time.to_s
 
     # rm_sd_rt
 
@@ -180,15 +235,26 @@ class TestParsing < Test::Unit::TestCase
     # old dates
 
     time = parse_now("may 40")
-    assert_equal Time.local(40, 5, 16, 12, 0, 0), time
+    assert_equal Time.local(2040, 5, 16, 12, 0, 0), time
 
     time = parse_now("may 27 40")
-    assert_equal Time.local(40, 5, 27, 12, 0, 0), time
+    assert_equal Time.local(2040, 5, 27, 12, 0, 0), time
 
     time = parse_now("1800-08-20")
     assert_equal Time.local(1800, 8, 20, 12, 0, 0), time
   end
 
+  def test_parse_two_digit_years
+    time = parse_now("may 97")
+    assert_equal Time.local(1997, 5, 16, 12), time
+
+    time = parse_now("may 1st 01")
+    assert_equal Time.local(2001, 5, 1, 12), time
+
+    time = parse_now("may 79", :ambiguous_year_future_bias => 10)
+    assert_equal Time.local(2079, 5, 16, 12), time
+  end
+
   def test_parse_guess_r
     time = parse_now("friday")
     assert_equal Time.local(2006, 8, 18, 12), time
@@ -246,6 +312,9 @@ class TestParsing < Test::Unit::TestCase
     time = parse_now("4:00 in the morning")
     assert_equal Time.local(2006, 8, 16, 4), time
 
+    time = parse_now("0:10")
+    assert_equal Time.local(2006, 8, 17, 0, 10), time
+
     time = parse_now("november 4")
     assert_equal Time.local(2006, 11, 4, 12), time
 
@@ -325,17 +394,21 @@ class TestParsing < Test::Unit::TestCase
     # day
 
     time = parse_now("this day")
-    assert_equal Time.local(2006, 8, 16, 19, 30), time
+    assert_equal Time.local(2006, 8, 16, 19), time
 
     time = parse_now("this day", :context => :past)
     assert_equal Time.local(2006, 8, 16, 7), time
 
     time = parse_now("today")
-    assert_equal Time.local(2006, 8, 16, 19, 30), time
+    assert_equal Time.local(2006, 8, 16, 19), time
 
     time = parse_now("yesterday")
     assert_equal Time.local(2006, 8, 15, 12), time
 
+    now = Time.parse("2011-05-27 23:10") # after 11pm
+    time = parse_now("yesterday", :now => now)
+    assert_equal Time.local(2011, 05, 26, 12), time
+
     time = parse_now("tomorrow")
     assert_equal Time.local(2006, 8, 17, 12), time
 
@@ -452,6 +525,10 @@ class TestParsing < Test::Unit::TestCase
 
     time = parse_now("next monday at 12:01 pm")
     assert_equal Time.local(2006, 8, 21, 12, 1), time
+
+    # with context
+    time = parse_now("sunday at 8:15pm", :context => :past)
+    assert_equal Time.local(2006, 8, 13, 20, 15), time
   end
 
   def test_parse_guess_rgr
@@ -578,12 +655,19 @@ class TestParsing < Test::Unit::TestCase
   end
 
   def test_parse_guess_o_r_g_r
-    time = parse_now("3rd month next year")
-    assert_equal Time.local(2007, 3, 16, 12, 30), time
+    time = parse_now("3rd month next year", :guess => false)
+    assert_equal Time.local(2007, 3), time.begin
+
+    time = parse_now("3rd month next year", :guess => false)
+    assert_equal Time.local(2007, 3, 1), time.begin
 
     time = parse_now("3rd thursday this september")
     assert_equal Time.local(2006, 9, 21, 12), time
 
+    now = Time.parse("1/10/2010")
+    time = parse_now("3rd thursday this november", :now => now)
+    assert_equal Time.local(2010, 11, 18, 12), time
+
     time = parse_now("4th day last week")
     assert_equal Time.local(2006, 8, 9, 12), time
   end
@@ -662,16 +746,16 @@ class TestParsing < Test::Unit::TestCase
     assert_equal Time.local(2007, 6, 20), t.end
 
     t = parse_now("this winter", :guess => false)
-    assert_equal Time.local(2006, 12, 22, 23), t.begin
+    assert_equal Time.local(2006, 12, 22), t.begin
     assert_equal Time.local(2007, 3, 19), t.end
 
     t = parse_now("last spring", :guess => false)
-    assert_equal Time.local(2006, 3, 20, 23), t.begin
+    assert_equal Time.local(2006, 3, 20), t.begin
     assert_equal Time.local(2006, 6, 20), t.end
 
     t = parse_now("last winter", :guess => false)
-    assert_equal Time.local(2005, 12, 22, 23), t.begin
-    assert_equal Time.local(2006, 3, 19, 23), t.end
+    assert_equal Time.local(2005, 12, 22), t.begin
+    assert_equal Time.local(2006, 3, 19), t.end
 
     t = parse_now("next spring", :guess => false)
     assert_equal Time.local(2007, 3, 20), t.begin
@@ -694,8 +778,8 @@ class TestParsing < Test::Unit::TestCase
     t1 = Chronic.parse('1st saturday in november', :now => Time.local(2007))
     assert_equal Time.local(2007, 11, 3, 12), t1
 
-    t1 = Chronic.parse('1st sunday in november', :now => Time.local(2007))
-    assert_equal Time.local(2007, 11, 4, 11), t1
+    # t1 = Chronic.parse('1st sunday in november', :now => Time.local(2007))
+    # assert_equal Time.local(2007, 11, 4, 12), t1
 
     # Chronic.debug = true
     #
@@ -703,6 +787,13 @@ class TestParsing < Test::Unit::TestCase
     # assert_equal Time.local(2007, 11, 5, 11), t1
   end
 
+  def test_now_changes
+    t1 = Chronic.parse("now")
+    sleep 0.1
+    t2 = Chronic.parse("now")
+    assert_not_equal t1, t2
+  end
+
   private
   def parse_now(string, options={})
     Chronic.parse(string, {:now => TIME_2006_08_16_14_00_00 }.merge(options))