chronic 0.8.0 → 0.9.0

data/lib/chronic/{chronic.rb → parser.rb}

@@ -1,25 +1,23 @@
-module Chronic
-
-  # Returns a Hash of default configuration options.
-  DEFAULT_OPTIONS = {
-    :context => :future,
-    :now => nil,
-    :guess => true,
-    :ambiguous_time_range => 6,
-    :endian_precedence    => [:middle, :little],
-    :ambiguous_year_future_bias => 50
-  }
+require 'chronic/handlers'
 
-  class << self
+module Chronic
+  class Parser
+    include Handlers
+
+    # Hash of default configuration options.
+    DEFAULT_OPTIONS = {
+      :context => :future,
+      :now => nil,
+      :guess => true,
+      :ambiguous_time_range => 6,
+      :endian_precedence    => [:middle, :little],
+      :ambiguous_year_future_bias => 50
+    }
+
+    attr_accessor :now
+    attr_reader :options
 
-    # Parses a string containing a natural language date or time.
-    #
-    # If the parser can find a date or time, either a Time or Chronic::Span
-    # will be returned (depending on the value of `:guess`). If no
-    # date or time can be found, `nil` will be returned.
-    #
-    # text - The String text to parse.
-    # opts - An optional Hash of configuration options:
+    # options - An optional Hash of configuration options:
     #        :context - If your string represents a birthday, you can set
     #                   this value to :past and if an ambiguous string is
     #                   given, it will assume it is in the past.
@@ -47,31 +45,18 @@ module Chronic
     #                 look x amount of years into the future and past. If the
     #                 two digit year is `now + x years` it's assumed to be the
     #                 future, `now - x years` is assumed to be the past.
-    #
-    # Returns a new Time object, or Chronic::Span if :guess option is false.
-    def parse(text, opts={})
-      options = DEFAULT_OPTIONS.merge opts
-
-      # ensure the specified options are valid
-      (opts.keys - DEFAULT_OPTIONS.keys).each do |key|
-        raise ArgumentError, "#{key} is not a valid option key."
-      end
-
-      unless [:past, :future, :none].include?(options[:context])
-        raise ArgumentError, "Invalid context, :past/:future only"
-      end
-
-      options[:text] = text
-      Chronic.now = options[:now] || Chronic.time_class.now
+    def initialize(options = {})
+      @options = DEFAULT_OPTIONS.merge(options)
+      @now = options.delete(:now) || Chronic.time_class.now
+    end
 
-      # tokenize words
+    # Parse "text" with the given options
+    # Returns either a Time or Chronic::Span, depending on the value of options[:guess]
+    def parse(text)
       tokens = tokenize(text, options)
+      span = tokens_to_span(tokens, options.merge(:text => text))
 
-      if Chronic.debug
-        puts "+#{'-' * 51}\n| #{tokens}\n+#{'-' * 51}"
-      end
-
-      span = tokens_to_span(tokens, options)
+      puts "+#{'-' * 51}\n| #{tokens}\n+#{'-' * 51}" if Chronic.debug
 
       if span
         options[:guess] ? guess(span) : span
@@ -107,7 +92,7 @@ module Chronic
       text.gsub!(/^second /, '2nd ')
       text.gsub!(/\bsecond (of|day|month|hour|minute|second)\b/, '2nd \1')
       text = Numerizer.numerize(text)
-      text.gsub!(/ \-(\d{4})\b/, ' tzminus\1')
+      text.gsub!(/\-(\d{2}:?\d{2})\b/, 'tzminus\1')
       text.gsub!(/([\/\-\,\@])/) { ' ' + $1 + ' ' }
       text.gsub!(/(?:^|\s)0(\d+:\d+\s*pm?\b)/, ' \1')
       text.gsub!(/\btoday\b/, 'this day')
@@ -116,12 +101,17 @@ module Chronic
       text.gsub!(/\bnoon\b/, '12:00pm')
       text.gsub!(/\bmidnight\b/, '24:00')
       text.gsub!(/\bnow\b/, 'this second')
+      text.gsub!('quarter', '15')
+      text.gsub!('half', '30')
+      text.gsub!(/(\d{1,2}) (to|till|prior to|before)\b/, '\1 minutes past')
+      text.gsub!(/(\d{1,2}) (after|past)\b/, '\1 minutes future')
       text.gsub!(/\b(?:ago|before(?: now)?)\b/, 'past')
       text.gsub!(/\bthis (?:last|past)\b/, 'last')
       text.gsub!(/\b(?:in|during) the (morning)\b/, '\1')
       text.gsub!(/\b(?:in the|during the|at) (afternoon|evening|night)\b/, '\1')
       text.gsub!(/\btonight\b/, 'this night')
       text.gsub!(/\b\d+:?\d*[ap]\b/,'\0m')
+      text.gsub!(/\b(\d{2})(\d{2})(am|pm)\b/, '\1:\2\3')
       text.gsub!(/(\d)([ap]m|oclock)\b/, '\1 \2')
       text.gsub!(/\b(hence|after|from)\b/, 'future')
       text.gsub!(/^\s?an? /i, '1 ')
@@ -129,16 +119,6 @@ module Chronic
       text
     end
 
-    # Convert number words to numbers (three => 3, fourth => 4th).
-    #
-    # text - The String to convert.
-    #
-    # Returns a new String with words converted to numbers.
-    def numericize_numbers(text)
-      warn "Chronic.numericize_numbers will be deprecated in version 0.7.0. Please use Chronic::Numerizer.numerize instead"
-      Numerizer.numerize(text)
-    end
-
     # Guess a specific time within the given span.
     #
     # span - The Chronic::Span object to calcuate a guess from.
@@ -152,17 +132,16 @@ module Chronic
       end
     end
 
-    # List of Handler definitions. See #parse for a list of options this
+    # List of Handler definitions. See Chronic.parse for a list of options this
     # method accepts.
     #
-    # options - An optional Hash of configuration options:
-    #           :endian_precedence -
+    # options - An optional Hash of configuration options.
     #
-    # Returns A Hash of Handler definitions.
-    def definitions(options={})
+    # Returns a Hash of Handler definitions.
+    def definitions(options = {})
       options[:endian_precedence] ||= [:middle, :little]
 
-      @definitions ||= {
+      @@definitions ||= {
         :time => [
           Handler.new([:repeater_time, :repeater_day_portion?], nil)
         ],
@@ -172,12 +151,15 @@ module Chronic
           Handler.new([:repeater_day_name, :repeater_month_name, :scalar_day], :handle_rdn_rmn_sd),
           Handler.new([:repeater_day_name, :repeater_month_name, :scalar_day, :scalar_year], :handle_rdn_rmn_sd_sy),
           Handler.new([:repeater_day_name, :repeater_month_name, :ordinal_day], :handle_rdn_rmn_od),
+          Handler.new([:repeater_day_name, :repeater_month_name, :scalar_day, :separator_at?, 'time?'], :handle_rdn_rmn_sd),
+          Handler.new([:repeater_day_name, :repeater_month_name, :ordinal_day, :separator_at?, 'time?'], :handle_rdn_rmn_od),
+          Handler.new([:repeater_day_name, :ordinal_day, :separator_at?, 'time?'], :handle_rdn_od),
           Handler.new([:scalar_year, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :scalar_day, :repeater_time, :time_zone], :handle_generic),
           Handler.new([:repeater_month_name, :scalar_day, :scalar_year], :handle_rmn_sd_sy),
           Handler.new([:repeater_month_name, :ordinal_day, :scalar_year], :handle_rmn_od_sy),
           Handler.new([:repeater_month_name, :scalar_day, :scalar_year, :separator_at?, 'time?'], :handle_rmn_sd_sy),
           Handler.new([:repeater_month_name, :ordinal_day, :scalar_year, :separator_at?, 'time?'], :handle_rmn_od_sy),
-          Handler.new([:repeater_month_name, :scalar_day, :separator_at?, 'time?'], :handle_rmn_sd),
+          Handler.new([:repeater_month_name, :separator_slash_or_dash?, :scalar_day, :separator_at?, 'time?'], :handle_rmn_sd),
           Handler.new([:repeater_time, :repeater_day_portion?, :separator_on?, :repeater_month_name, :scalar_day], :handle_rmn_sd_on),
           Handler.new([:repeater_month_name, :ordinal_day, :separator_at?, 'time?'], :handle_rmn_od),
           Handler.new([:ordinal_day, :repeater_month_name, :scalar_year, :separator_at?, 'time?'], :handle_od_rmn_sy),
@@ -187,29 +169,26 @@ module Chronic
           Handler.new([:repeater_time, :repeater_day_portion?, :separator_on?, :repeater_month_name, :ordinal_day], :handle_rmn_od_on),
           Handler.new([:repeater_month_name, :scalar_year], :handle_rmn_sy),
           Handler.new([:scalar_day, :repeater_month_name, :scalar_year, :separator_at?, 'time?'], :handle_sd_rmn_sy),
-          Handler.new([:scalar_day, :repeater_month_name, :separator_at?, 'time?'], :handle_sd_rmn),
+          Handler.new([:scalar_day, :separator_slash_or_dash?, :repeater_month_name, :separator_at?, 'time?'], :handle_sd_rmn),
           Handler.new([:scalar_year, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :scalar_day, :separator_at?, 'time?'], :handle_sy_sm_sd),
           Handler.new([:scalar_month, :separator_slash_or_dash, :scalar_year], :handle_sm_sy),
           Handler.new([:scalar_day, :separator_slash_or_dash, :repeater_month_name, :separator_slash_or_dash, :scalar_year, :repeater_time?], :handle_sm_rmn_sy),
-          Handler.new([:scalar_year, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :time_zone], :handle_generic)
-
+          Handler.new([:scalar_year, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :scalar?, :time_zone], :handle_generic),
         ],
 
-        # tonight at 7pm
         :anchor => [
           Handler.new([:separator_on?, :grabber?, :repeater, :separator_at?, :repeater?, :repeater?], :handle_r),
           Handler.new([:grabber?, :repeater, :repeater, :separator?, :repeater?, :repeater?], :handle_r),
           Handler.new([:repeater, :grabber, :repeater], :handle_r_g_r)
         ],
 
-        # 3 weeks from now, in 2 months
         :arrow => [
           Handler.new([:scalar, :repeater, :pointer], :handle_s_r_p),
+          Handler.new([:scalar, :repeater, :separator_and?, :scalar, :repeater, :pointer, :separator_at?, 'anchor'], :handle_s_r_a_s_r_p_a),
           Handler.new([:pointer, :scalar, :repeater], :handle_p_s_r),
           Handler.new([:scalar, :repeater, :pointer, :separator_at?, 'anchor'], :handle_s_r_p_a)
         ],
 
-        # 3rd week in march
         :narrow => [
           Handler.new([:ordinal, :repeater, :separator_in, :repeater], :handle_o_r_s_r),
           Handler.new([:ordinal, :repeater, :grabber, :repeater], :handle_o_r_g_r)
@@ -225,68 +204,12 @@ module Chronic
 
       case endian = Array(options[:endian_precedence]).first
       when :little
-        @definitions[:endian] = endians.reverse
+        @@definitions.merge(:endian => endians.reverse)
       when :middle
-        @definitions[:endian] = endians
+        @@definitions.merge(:endian => endians)
       else
         raise ArgumentError, "Unknown endian option '#{endian}'"
       end
-
-      @definitions
-    end
-
-    # Construct a new time object determining possible month overflows
-    # and leap years.
-    #
-    # year   - Integer year.
-    # month  - Integer month.
-    # day    - Integer day.
-    # hour   - Integer hour.
-    # minute - Integer minute.
-    # second - Integer second.
-    #
-    # Returns a new Time object constructed from these params.
-    def 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
-
-      # determine if there is a day overflow. this is complicated by our crappy calendar
-      # system (non-constant number of days per month)
-      day <= 56 || raise("day must be no more than 56 (makes month resolution easier)")
-      if day > 28
-        # no month ever has fewer than 28 days, so only do this if necessary
-        leap_year_month_days = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
-        common_year_month_days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
-        days_this_month = Date.leap?(year) ? leap_year_month_days[month - 1] : common_year_month_days[month - 1]
-        if day > days_this_month
-          month += day / days_this_month
-          day = day % days_this_month
-        end
-      end
-
-      if month > 12
-        if month % 12 == 0
-          year += (month - 12) / 12
-          month = 12
-        else
-          year += month / 12
-          month = month % 12
-        end
-      end
-
-      Chronic.time_class.local(year, month, day, hour, minute, second)
     end
 
     private
@@ -306,37 +229,32 @@ module Chronic
       (definitions[:endian] + definitions[:date]).each do |handler|
         if handler.match(tokens, definitions)
           good_tokens = tokens.select { |o| !o.get_tag Separator }
-          return handler.invoke(:date, good_tokens, options)
+          return handler.invoke(:date, good_tokens, self, options)
         end
       end
 
       definitions[:anchor].each do |handler|
         if handler.match(tokens, definitions)
           good_tokens = tokens.select { |o| !o.get_tag Separator }
-          return handler.invoke(:anchor, good_tokens, options)
+          return handler.invoke(:anchor, good_tokens, self, options)
         end
       end
 
       definitions[:arrow].each do |handler|
         if handler.match(tokens, definitions)
-          good_tokens = tokens.reject { |o| o.get_tag(SeparatorAt) || o.get_tag(SeparatorSlashOrDash) || o.get_tag(SeparatorComma) }
-          return handler.invoke(:arrow, good_tokens, options)
+          good_tokens = tokens.reject { |o| o.get_tag(SeparatorAt) || o.get_tag(SeparatorSlashOrDash) || o.get_tag(SeparatorComma) || o.get_tag(SeparatorAnd) }
+          return handler.invoke(:arrow, good_tokens, self, options)
         end
       end
 
       definitions[:narrow].each do |handler|
         if handler.match(tokens, definitions)
-          return handler.invoke(:narrow, tokens, options)
+          return handler.invoke(:narrow, tokens, self, options)
         end
       end
 
       puts "-none" if Chronic.debug
       return nil
     end
-
-  end
-
-  # Internal exception
-  class ChronicPain < Exception
   end
 end

data/lib/chronic/repeater.rb

@@ -38,18 +38,18 @@ module Chronic
     def self.scan_for_month_names(token)
       scan_for token, RepeaterMonthName,
       {
-        /^jan\.?(uary)?$/ => :january,
-        /^feb\.?(ruary)?$/ => :february,
-        /^mar\.?(ch)?$/ => :march,
-        /^apr\.?(il)?$/ => :april,
+        /^jan[:\.]?(uary)?$/ => :january,
+        /^feb[:\.]?(ruary)?$/ => :february,
+        /^mar[:\.]?(ch)?$/ => :march,
+        /^apr[:\.]?(il)?$/ => :april,
         /^may$/ => :may,
-        /^jun\.?e?$/ => :june,
-        /^jul\.?y?$/ => :july,
-        /^aug\.?(ust)?$/ => :august,
-        /^sep\.?(t\.?|tember)?$/ => :september,
-        /^oct\.?(ober)?$/ => :october,
-        /^nov\.?(ember)?$/ => :november,
-        /^dec\.?(ember)?$/ => :december
+        /^jun[:\.]?e?$/ => :june,
+        /^jul[:\.]?y?$/ => :july,
+        /^aug[:\.]?(ust)?$/ => :august,
+        /^sep[:\.]?(t[:\.]?|tember)?$/ => :september,
+        /^oct[:\.]?(ober)?$/ => :october,
+        /^nov[:\.]?(ember)?$/ => :november,
+        /^dec[:\.]?(ember)?$/ => :december
       }
     end
 

data/lib/chronic/separator.rb

@@ -15,6 +15,7 @@ module Chronic
         if t = scan_for_at(token) then token.tag(t); next end
         if t = scan_for_in(token) then token.tag(t); next end
         if t = scan_for_on(token) then token.tag(t); next end
+        if t = scan_for_and(token) then token.tag(t); next end
       end
     end
 
@@ -57,6 +58,13 @@ module Chronic
       scan_for token, SeparatorOn, { /^on$/ => :on }
     end
 
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeperatorAnd Object object.
+    def self.scan_for_and(token)
+      scan_for token, SeparatorAnd, { /^and$/ => :and }
+    end
+
     def to_s
       'separator'
     end
@@ -91,4 +99,10 @@ module Chronic
       super << '-on'
     end
   end
-end
+
+  class SeparatorAnd < Separator #:nodoc:
+    def to_s
+      super << '-and'
+    end
+  end
+end

data/test/test_chronic.rb

@@ -8,12 +8,12 @@ class TestChronic < TestCase
   end
 
   def test_pre_normalize
-    assert_equal Chronic.pre_normalize('12:55 pm'), Chronic.pre_normalize('12.55 pm')
+    assert_equal Chronic::Parser.new.pre_normalize('12:55 pm'), Chronic::Parser.new.pre_normalize('12.55 pm')
   end
 
   def test_pre_normalize_numerized_string
     string = 'two and a half years'
-    assert_equal Chronic::Numerizer.numerize(string), Chronic.pre_normalize(string)
+    assert_equal Chronic::Numerizer.numerize(string), Chronic::Parser.new.pre_normalize(string)
   end
 
   def test_post_normalize_am_pm_aliases
@@ -46,21 +46,13 @@ class TestChronic < TestCase
 
   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)
+    assert_equal Time.local(2006, 8, 16, 12), Chronic::Parser.new.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)
+    assert_equal Time.local(2006, 8, 16, 12), Chronic::Parser.new.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
-
-  def test_now
-    Chronic.parse('now', :now => Time.local(2006, 01))
-    assert_equal Time.local(2006, 01), Chronic.now
-
-    Chronic.parse('now', :now => Time.local(2007, 01))
-    assert_equal Time.local(2007, 01), Chronic.now
+    assert_equal Time.local(2006, 11, 16), Chronic::Parser.new.guess(span)
   end
 
   def test_endian_definitions
@@ -72,26 +64,16 @@ class TestChronic < TestCase
       Chronic::Handler.new([:scalar_day, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :scalar_year, :separator_at?, 'time?'], :handle_sd_sm_sy)
     ]
 
-    assert_equal endians, Chronic.definitions[:endian]
+    assert_equal endians, Chronic::Parser.new.definitions[:endian]
 
-    defs = Chronic.definitions(:endian_precedence => :little)
+    defs = Chronic::Parser.new.definitions(:endian_precedence => :little)
     assert_equal endians.reverse, defs[:endian]
 
-    defs = Chronic.definitions(:endian_precedence => [:little, :middle])
+    defs = Chronic::Parser.new.definitions(:endian_precedence => [:little, :middle])
     assert_equal endians.reverse, defs[:endian]
 
     assert_raises(ArgumentError) do
-      Chronic.definitions(:endian_precedence => :invalid)
-    end
-  end
-
-  def test_passing_options
-    assert_raises(ArgumentError) do
-      Chronic.parse('now', :invalid => :option)
-    end
-
-    assert_raises(ArgumentError) do
-      Chronic.parse('now', :context => :invalid_context)
+      Chronic::Parser.new.definitions(:endian_precedence => :invalid)
     end
   end
 

data/test/test_handler.rb

@@ -7,18 +7,22 @@ class TestHandler < TestCase
     @now = Time.local(2006, 8, 16, 14, 0, 0, 0)
   end
 
+  def definitions
+    @definitions ||= Chronic::Parser.new.definitions
+  end
+
   def test_handler_class_1
     handler = Chronic::Handler.new([:repeater], :handler)
 
     tokens = [Chronic::Token.new('friday')]
     tokens[0].tag(Chronic::RepeaterDayName.new(:friday))
 
-    assert handler.match(tokens, Chronic.definitions)
+    assert handler.match(tokens, definitions)
 
     tokens << Chronic::Token.new('afternoon')
     tokens[1].tag(Chronic::RepeaterDayPortion.new(:afternoon))
 
-    assert !handler.match(tokens, Chronic.definitions)
+    assert !handler.match(tokens, definitions)
   end
 
   def test_handler_class_2
@@ -27,17 +31,17 @@ class TestHandler < TestCase
     tokens = [Chronic::Token.new('friday')]
     tokens[0].tag(Chronic::RepeaterDayName.new(:friday))
 
-    assert handler.match(tokens, Chronic.definitions)
+    assert handler.match(tokens, definitions)
 
     tokens << Chronic::Token.new('afternoon')
     tokens[1].tag(Chronic::RepeaterDayPortion.new(:afternoon))
 
-    assert handler.match(tokens, Chronic.definitions)
+    assert handler.match(tokens, definitions)
 
     tokens << Chronic::Token.new('afternoon')
     tokens[2].tag(Chronic::RepeaterDayPortion.new(:afternoon))
 
-    assert !handler.match(tokens, Chronic.definitions)
+    assert !handler.match(tokens, definitions)
   end
 
   def test_handler_class_3
@@ -46,12 +50,12 @@ class TestHandler < TestCase
     tokens = [Chronic::Token.new('friday')]
     tokens[0].tag(Chronic::RepeaterDayName.new(:friday))
 
-    assert handler.match(tokens, Chronic.definitions)
+    assert handler.match(tokens, definitions)
 
     tokens << Chronic::Token.new('afternoon')
     tokens[1].tag(Chronic::RepeaterDayPortion.new(:afternoon))
 
-    assert !handler.match(tokens, Chronic.definitions)
+    assert !handler.match(tokens, definitions)
   end
 
   def test_handler_class_4
@@ -60,12 +64,12 @@ class TestHandler < TestCase
     tokens = [Chronic::Token.new('may')]
     tokens[0].tag(Chronic::RepeaterMonthName.new(:may))
 
-    assert !handler.match(tokens, Chronic.definitions)
+    assert !handler.match(tokens, definitions)
 
     tokens << Chronic::Token.new('27')
     tokens[1].tag(Chronic::ScalarDay.new(27))
 
-    assert handler.match(tokens, Chronic.definitions)
+    assert handler.match(tokens, definitions)
   end
 
   def test_handler_class_5
@@ -74,17 +78,17 @@ class TestHandler < TestCase
     tokens = [Chronic::Token.new('friday')]
     tokens[0].tag(Chronic::RepeaterDayName.new(:friday))
 
-    assert handler.match(tokens, Chronic.definitions)
+    assert handler.match(tokens, definitions)
 
     tokens << Chronic::Token.new('5:00')
     tokens[1].tag(Chronic::RepeaterTime.new('5:00'))
 
-    assert handler.match(tokens, Chronic.definitions)
+    assert handler.match(tokens, definitions)
 
     tokens << Chronic::Token.new('pm')
     tokens[2].tag(Chronic::RepeaterDayPortion.new(:pm))
 
-    assert handler.match(tokens, Chronic.definitions)
+    assert handler.match(tokens, definitions)
   end
 
   def test_handler_class_6
@@ -98,7 +102,7 @@ class TestHandler < TestCase
     tokens[1].tag(Chronic::RepeaterYear.new(:year))
     tokens[2].tag(Chronic::Pointer.new(:past))
 
-    assert handler.match(tokens, Chronic.definitions)
+    assert handler.match(tokens, definitions)
   end
 
 end