chronic 0.6.3 → 0.10.2

data/lib/chronic/handlers.rb

@@ -4,7 +4,7 @@ module Chronic
 
     # Handle month/day
     def handle_m_d(month, day, time_tokens, options)
-      month.start = Chronic.now
+      month.start = self.now
       span = month.this(options[:context])
       year, month = span.begin.year, span.begin.month
       day_start = Chronic.time_class.local(year, month, day)
@@ -17,7 +17,7 @@ module Chronic
       month = tokens[0].get_tag(RepeaterMonthName)
       day = tokens[1].get_tag(ScalarDay).type
 
-      return if month_overflow?(Chronic.now.year, month.index, day)
+      return if month_overflow?(self.now.year, month.index, day)
 
       handle_m_d(month, day, tokens[2..tokens.size], options)
     end
@@ -34,7 +34,7 @@ module Chronic
         token_range = 0..0
       end
 
-      return if month_overflow?(Chronic.now.year, month.index, day)
+      return if month_overflow?(self.now.year, month.index, day)
 
       handle_m_d(month, day, tokens[token_range], options)
     end
@@ -44,17 +44,50 @@ module Chronic
       month = tokens[0].get_tag(RepeaterMonthName)
       day = tokens[1].get_tag(OrdinalDay).type
 
-      return if month_overflow?(Chronic.now.year, month.index, day)
+      return if month_overflow?(self.now.year, month.index, day)
 
       handle_m_d(month, day, tokens[2..tokens.size], options)
     end
 
+    # Handle ordinal this month
+    def handle_od_rm(tokens, options)
+      day = tokens[0].get_tag(OrdinalDay).type
+      month = tokens[2].get_tag(RepeaterMonth)
+      handle_m_d(month, day, tokens[3..tokens.size], options)
+    end
+
     # Handle ordinal-day/repeater-month-name
     def handle_od_rmn(tokens, options)
       month = tokens[1].get_tag(RepeaterMonthName)
       day = tokens[0].get_tag(OrdinalDay).type
 
-      return if month_overflow?(Chronic.now.year, month.index, day)
+      return if month_overflow?(self.now.year, month.index, day)
+
+      handle_m_d(month, day, tokens[2..tokens.size], options)
+    end
+
+    def handle_sy_rmn_od(tokens, options)
+      year = tokens[0].get_tag(ScalarYear).type
+      month = tokens[1].get_tag(RepeaterMonthName).index
+      day = tokens[2].get_tag(OrdinalDay).type
+      time_tokens = tokens.last(tokens.size - 3)
+
+      return if month_overflow?(year, month, day)
+
+      begin
+        day_start = Chronic.time_class.local(year, month, day)
+        day_or_time(day_start, time_tokens, options)
+      rescue ArgumentError
+        nil
+      end
+    end
+
+    # Handle scalar-day/repeater-month-name
+    def handle_sd_rmn(tokens, options)
+      month = tokens[1].get_tag(RepeaterMonthName)
+      day = tokens[0].get_tag(ScalarDay).type
+
+      return if month_overflow?(self.now.year, month.index, day)
 
       handle_m_d(month, day, tokens[2..tokens.size], options)
     end
@@ -71,7 +104,7 @@ module Chronic
         token_range = 0..0
       end
 
-      return if month_overflow?(Chronic.now.year, month.index, day)
+      return if month_overflow?(self.now.year, month.index, day)
 
       handle_m_d(month, day, tokens[token_range], options)
     end
@@ -98,15 +131,11 @@ module Chronic
     end
 
     # Handle generic timestamp (ruby 1.8)
-    def handle_rdn_rmn_sd_t_tz_sy(tokens, options)
-      t = Chronic.time_class.parse(options[:text])
-      Span.new(t, t + 1)
-    end
-
-    # Handle generic timestamp (ruby 1.9)
-    def handle_sy_sm_sd_t_tz(tokens, options)
+    def handle_generic(tokens, options)
       t = Chronic.time_class.parse(options[:text])
       Span.new(t, t + 1)
+    rescue ArgumentError => e
+      raise e unless e.message =~ /out of range/
     end
 
     # Handle repeater-month-name/scalar-day/scalar-year
@@ -198,11 +227,32 @@ module Chronic
       handle_sm_sd_sy(new_tokens + time_tokens, options)
     end
 
-    # Handle scalar-month/scalar-year
-    def handle_sm_sy(tokens, options)
+    # Handle scalar-month/scalar-day
+    def handle_sm_sd(tokens, options)
       month = tokens[0].get_tag(ScalarMonth).type
-      year = tokens[1].get_tag(ScalarYear).type
+      day = tokens[1].get_tag(ScalarDay).type
+      year = self.now.year
+      time_tokens = tokens.last(tokens.size - 2)
+
+      return if month_overflow?(year, month, day)
+
+      begin
+        day_start = Chronic.time_class.local(year, month, day)
+        day_start = Chronic.time_class.local(year + 1, month, day) if options[:context] == :future && day_start < now
+        day_or_time(day_start, time_tokens, options)
+      rescue ArgumentError
+        nil
+      end
+    end
+
+    # Handle scalar-day/scalar-month
+    def handle_sd_sm(tokens, options)
+      new_tokens = [tokens[1], tokens[0]]
+      time_tokens = tokens.last(tokens.size - 2)
+      handle_sm_sd(new_tokens + time_tokens, options)
+    end
 
+    def handle_year_and_month(year, month)
       if month == 12
         next_month_year = year + 1
         next_month_month = 1
@@ -219,6 +269,143 @@ module Chronic
       end
     end
 
+    # Handle scalar-month/scalar-year
+    def handle_sm_sy(tokens, options)
+      month = tokens[0].get_tag(ScalarMonth).type
+      year = tokens[1].get_tag(ScalarYear).type
+      handle_year_and_month(year, month)
+    end
+
+    # Handle scalar-year/scalar-month
+    def handle_sy_sm(tokens, options)
+      year = tokens[0].get_tag(ScalarYear).type
+      month = tokens[1].get_tag(ScalarMonth).type
+      handle_year_and_month(year, month)
+    end
+
+    # Handle RepeaterDayName RepeaterMonthName OrdinalDay
+    def handle_rdn_rmn_od(tokens, options)
+      month = tokens[1].get_tag(RepeaterMonthName)
+      day = tokens[2].get_tag(OrdinalDay).type
+      time_tokens = tokens.last(tokens.size - 3)
+      year = self.now.year
+
+      return if month_overflow?(year, month.index, day)
+
+      begin
+        if time_tokens.empty?
+          start_time = Chronic.time_class.local(year, month.index, day)
+          end_time = time_with_rollover(year, month.index, day + 1)
+          Span.new(start_time, end_time)
+        else
+          day_start = Chronic.time_class.local(year, month.index, day)
+          day_or_time(day_start, time_tokens, options)
+        end
+      rescue ArgumentError
+        nil
+      end
+    end
+
+    # Handle RepeaterDayName RepeaterMonthName OrdinalDay ScalarYear
+    def handle_rdn_rmn_od_sy(tokens, options)
+      month = tokens[1].get_tag(RepeaterMonthName)
+      day = tokens[2].get_tag(OrdinalDay).type
+      year = tokens[3].get_tag(ScalarYear).type
+
+      return if month_overflow?(year, month.index, day)
+
+      begin
+        start_time = Chronic.time_class.local(year, month.index, day)
+        end_time = time_with_rollover(year, month.index, day + 1)
+        Span.new(start_time, end_time)
+      rescue ArgumentError
+        nil
+      end
+    end
+
+    # Handle RepeaterDayName OrdinalDay
+    def handle_rdn_od(tokens, options)
+      day = tokens[1].get_tag(OrdinalDay).type
+      time_tokens = tokens.last(tokens.size - 2)
+      year = self.now.year
+      month = self.now.month
+      if options[:context] == :future
+        self.now.day > day ? month += 1 : month
+      end
+
+      return if month_overflow?(year, month, day)
+
+      begin
+        if time_tokens.empty?
+          start_time = Chronic.time_class.local(year, month, day)
+          end_time = time_with_rollover(year, month, day + 1)
+          Span.new(start_time, end_time)
+        else
+          day_start = Chronic.time_class.local(year, month, day)
+          day_or_time(day_start, time_tokens, options)
+        end
+      rescue ArgumentError
+        nil
+      end
+    end
+
+    # Handle RepeaterDayName RepeaterMonthName ScalarDay
+    def handle_rdn_rmn_sd(tokens, options)
+      month = tokens[1].get_tag(RepeaterMonthName)
+      day = tokens[2].get_tag(ScalarDay).type
+      time_tokens = tokens.last(tokens.size - 3)
+      year = self.now.year
+
+      return if month_overflow?(year, month.index, day)
+
+      begin
+        if time_tokens.empty?
+          start_time = Chronic.time_class.local(year, month.index, day)
+          end_time = time_with_rollover(year, month.index, day + 1)
+          Span.new(start_time, end_time)
+        else
+          day_start = Chronic.time_class.local(year, month.index, day)
+          day_or_time(day_start, time_tokens, options)
+        end
+      rescue ArgumentError
+        nil
+      end
+    end
+
+    # Handle RepeaterDayName RepeaterMonthName ScalarDay ScalarYear
+    def handle_rdn_rmn_sd_sy(tokens, options)
+      month = tokens[1].get_tag(RepeaterMonthName)
+      day = tokens[2].get_tag(ScalarDay).type
+      year = tokens[3].get_tag(ScalarYear).type
+
+      return if month_overflow?(year, month.index, day)
+
+      begin
+        start_time = Chronic.time_class.local(year, month.index, day)
+        end_time = time_with_rollover(year, month.index, day + 1)
+        Span.new(start_time, end_time)
+      rescue ArgumentError
+        nil
+      end
+    end
+
+    def handle_sm_rmn_sy(tokens, options)
+      day = tokens[0].get_tag(ScalarDay).type
+      month = tokens[1].get_tag(RepeaterMonthName).index
+      year = tokens[2].get_tag(ScalarYear).type
+      if tokens.size > 3
+        time = get_anchor([tokens.last], options).begin
+        h, m, s = time.hour, time.min, time.sec
+        time = Chronic.time_class.local(year, month, day, h, m, s)
+        end_time = Chronic.time_class.local(year, month, day + 1, h, m, s)
+      else
+        time = Chronic.time_class.local(year, month, day)
+        day += 1 unless day >= 31
+        end_time = Chronic.time_class.local(year, month, day)
+      end
+      Span.new(time, end_time)
+    end
+
     # anchors
 
     # Handle repeaters
@@ -241,13 +428,12 @@ module Chronic
       repeater = tokens[1].get_tag(Repeater)
       pointer = tokens[2].get_tag(Pointer).type
 
-      repeater.offset(span, distance, pointer)
+      repeater.offset(span, distance, pointer) if repeater.respond_to?(:offset)
     end
 
     # Handle scalar/repeater/pointer
     def handle_s_r_p(tokens, options)
-      repeater = tokens[1].get_tag(Repeater)
-      span = Span.new(Chronic.now, Chronic.now + 1)
+      span = Span.new(self.now, self.now + 1)
 
       handle_srp(tokens, span, options)
     end
@@ -264,6 +450,13 @@ module Chronic
       handle_srp(tokens, anchor_span, options)
     end
 
+    def handle_s_r_a_s_r_p_a(tokens, options)
+      anchor_span = get_anchor(tokens[4..tokens.size - 1], options)
+
+      span = handle_srp(tokens[0..1]+tokens[4..6], anchor_span, options)
+      handle_srp(tokens[2..3]+tokens[4..6], span, options)
+    end
+
     # narrows
 
     # Handle oridinal repeaters
@@ -276,7 +469,7 @@ module Chronic
       ordinal.times do
         span = repeater.next(:future)
 
-        if span.begin > outer_span.end
+        if span.begin >= outer_span.end
           span = nil
           break
         end
@@ -302,9 +495,9 @@ module Chronic
     def day_or_time(day_start, time_tokens, options)
       outer_span = Span.new(day_start, day_start + (24 * 60 * 60))
 
-      if !time_tokens.empty?
-        Chronic.now = outer_span.begin
-        get_anchor(dealias_and_disambiguate_times(time_tokens, options), options)
+      unless time_tokens.empty?
+        self.now = outer_span.begin
+        get_anchor(dealias_and_disambiguate_times(time_tokens, options), options.merge(:context => :future))
       else
         outer_span
       end
@@ -313,7 +506,6 @@ module Chronic
     def get_anchor(tokens, options)
       grabber = Grabber.new(:this)
       pointer = :future
-
       repeaters = get_repeaters(tokens)
       repeaters.size.times { tokens.pop }
 
@@ -322,7 +514,7 @@ module Chronic
       end
 
       head = repeaters.shift
-      head.start = Chronic.now
+      head.start = self.now
 
       case grabber.type
       when :last
@@ -336,10 +528,14 @@ module Chronic
       when :next
         outer_span = head.next(:future)
       else
-        raise ChronicPain, "Invalid grabber"
+        raise "Invalid grabber"
+      end
+
+      if Chronic.debug
+        puts "Handler-class: #{head.class}"
+        puts "--#{outer_span}"
       end
 
-      puts "--#{outer_span}" if Chronic.debug
       find_within(repeaters, outer_span, pointer)
     end
 
@@ -348,11 +544,13 @@ module Chronic
     end
 
     def month_overflow?(year, month, day)
-      if Date.leap?(year)
+      if ::Date.leap?(year)
         day > RepeaterMonth::MONTH_DAYS_LEAP[month - 1]
       else
         day > RepeaterMonth::MONTH_DAYS[month - 1]
       end
+    rescue ArgumentError
+      false
     end
 
     # Recursively finds repeaters within other repeaters.
@@ -371,6 +569,20 @@ module Chronic
       end
     end
 
+    def time_with_rollover(year, month, day)
+      date_parts =
+        if month_overflow?(year, month, day)
+          if month == 12
+            [year + 1, 1, 1]
+          else
+            [year, month + 1, 1]
+          end
+        else
+          [year, month, day]
+        end
+      Chronic.time_class.local(*date_parts)
+    end
+
     def dealias_and_disambiguate_times(tokens, options)
       # handle aliases of am/pm
       # 5:00 in the morning -> 5:00 am

data/lib/chronic/numerizer.rb

@@ -37,7 +37,16 @@ module Chronic
       ['seventh', '7'],
       ['eighth', '8'],
       ['ninth', '9'],
-      ['tenth', '10']
+      ['tenth', '10'],
+      ['twelfth', '12'],
+      ['twentieth', '20'],
+      ['thirtieth', '30'],
+      ['fourtieth', '40'],
+      ['fiftieth', '50'],
+      ['sixtieth', '60'],
+      ['seventieth', '70'],
+      ['eightieth', '80'],
+      ['ninetieth', '90']
     ]
 
     TEN_PREFIXES = [
@@ -90,7 +99,7 @@ module Chronic
       # hundreds, thousands, millions, etc.
 
       BIG_PREFIXES.each do |bp|
-        string.gsub!(/(?:<num>)?(\d*) *#{bp[0]}/i) { '<num>' + (bp[1] * $1.to_i).to_s}
+        string.gsub!(/(?:<num>)?(\d*) *#{bp[0]}/i) { $1.empty? ? bp[1] : '<num>' + (bp[1] * $1.to_i).to_s}
         andition(string)
       end
 

data/lib/chronic/ordinal.rb

@@ -1,31 +1,24 @@
 module Chronic
   class Ordinal < Tag
 
-    # Scan an Array of {Token}s and apply any necessary Ordinal tags to
-    # each token
+    # Scan an Array of Token objects and apply any necessary Ordinal
+    # tags to each token.
     #
-    # @param [Array<Token>] tokens Array of tokens to scan
-    # @param [Hash] options Options specified in {Chronic.parse}
-    # @return [Array] list of tokens
+    # tokens - An Array of tokens to scan.
+    # options - The Hash of options specified in Chronic::parse.
+    #
+    # Returns an Array of tokens.
     def self.scan(tokens, options)
-      tokens.each do |token|
-        if t = scan_for_ordinals(token) then token.tag(t) end
-        if t = scan_for_days(token) then token.tag(t) end
-      end
-    end
-
-    # @param [Token] token
-    # @return [Ordinal, nil]
-    def self.scan_for_ordinals(token)
-      Ordinal.new($1.to_i) if token.word =~ /^(\d*)(st|nd|rd|th)$/
-    end
-
-    # @param [Token] token
-    # @return [OrdinalDay, nil]
-    def self.scan_for_days(token)
-      if token.word =~ /^(\d*)(st|nd|rd|th)$/
-        unless $1.to_i > 31 || $1.to_i < 1
-          OrdinalDay.new(token.word.to_i)
+      tokens.each_index do |i|
+        if tokens[i].word =~ /^(\d+)(st|nd|rd|th|\.)$/
+            ordinal = $1.to_i
+            tokens[i].tag(Ordinal.new(ordinal))
+            tokens[i].tag(OrdinalDay.new(ordinal)) if Chronic::Date::could_be_day?(ordinal)
+            tokens[i].tag(OrdinalMonth.new(ordinal)) if Chronic::Date::could_be_month?(ordinal)
+            if Chronic::Date::could_be_year?(ordinal)
+                year = Chronic::Date::make_year(ordinal, options[:ambiguous_year_future_bias])
+                tokens[i].tag(OrdinalYear.new(year.to_i))
+            end
         end
       end
     end
@@ -41,4 +34,16 @@ module Chronic
     end
   end
 
+  class OrdinalMonth < Ordinal #:nodoc:
+    def to_s
+      super << '-month-' << @type.to_s
+    end
+  end
+
+  class OrdinalYear < Ordinal #:nodoc:
+    def to_s
+      super << '-year-' << @type.to_s
+    end
+  end
+
 end