chronic 0.5.0 → 0.6.0

data/HISTORY.md

@@ -1,4 +1,17 @@
-# TBA
+# 0.6.0 / 2011-07-19
+
+* Attempting to parse strings with days past the last day of a month will
+  now return nil. ex: `Chronic.parse("30th February") #=> nil`
+* All deprecated methods are marked for removal in Chronic 0.7.0
+* Deprecated `Chronic.numericize_numbers` instead use
+  `Chronic::Numerizer.numerize`
+* Deprecated `Chronic::InvalidArgumentException` and instead use
+  `ArgumentError`
+* Deprecated `Time.construct` and use `Chronic.construct` in place of this
+* Deprecated `Time#to_minidate`, instead use `Chronic::MiniDate.from_time(time)`
+* Add support for handling generic timestamp for Ruby 1.9+
+
+# 0.5.0 / 2011-07-01
 
 * Replace commas with spaces instead of removing the char (Thomas Walpole)
 * Added tests for RepeaterSeason

data/lib/chronic.rb

@@ -28,7 +28,7 @@ require 'date'
 #
 # @author Tom Preston-Werner, Lee Jarvis
 module Chronic
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 
   class << self
 
@@ -65,6 +65,7 @@ module Chronic
 end
 
 require 'chronic/chronic'
+require 'chronic/handler'
 require 'chronic/handlers'
 require 'chronic/mini_date'
 require 'chronic/tag'
@@ -99,49 +100,12 @@ require 'chronic/repeaters/repeater_time'
 
 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
-
-    # 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)
+    warn "Chronic.construct will be deprecated in version 0.7.0. Please use Chronic.construct instead"
+    Chronic.construct(year, month, day, hour, minute, second)
   end
 
   def to_minidate
-    Chronic::MiniDate.new(self.month, self.day)
+    warn "Time.to_minidate will be deprecated in version 0.7.0. Please use Chronic::MiniDate.from_time(time) instead"
+    Chronic::MiniDate.from_time(self)
   end
 end

data/lib/chronic/chronic.rb

@@ -63,16 +63,15 @@ module Chronic
 
       # ensure the specified options are valid
       (opts.keys - DEFAULT_OPTIONS.keys).each do |key|
-        raise InvalidArgumentException, "#{key} is not a valid option key."
+        raise ArgumentError, "#{key} is not a valid option key."
       end
 
       unless [:past, :future, :none].include?(options[:context])
-        raise InvalidArgumentException, "Invalid context, :past/:future only"
+        raise ArgumentError, "Invalid context, :past/:future only"
       end
 
       options[:text] = text
-      options[:now] ||= Chronic.time_class.now
-      Chronic.now = options[:now]
+      Chronic.now = options[:now] || Chronic.time_class.now
 
       # tokenize words
       tokens = tokenize(text, options)
@@ -83,10 +82,8 @@ module Chronic
 
       span = tokens_to_span(tokens, options)
 
-      if options[:guess]
-        guess span
-      else
-        span
+      if span
+        options[:guess] ? guess(span) : span
       end
     end
 
@@ -112,9 +109,9 @@ module Chronic
     def pre_normalize(text)
       text = text.to_s.downcase
       text.gsub!(/['"\.]/, '')
-      text.gsub!(/,/,' ')
+      text.gsub!(/,/, ' ')
       text.gsub!(/\bsecond (of|day|month|hour|minute|second)\b/, '2nd \1')
-      text = numericize_numbers(text)
+      text = Numerizer.numerize(text)
       text.gsub!(/ \-(\d{4})\b/, ' tzminus\1')
       text.gsub!(/([\/\-\,\@])/) { ' ' + $1 + ' ' }
       text.gsub!(/\b0(\d+:\d+\s*pm?\b)/, '\1')
@@ -123,11 +120,9 @@ module Chronic
       text.gsub!(/\byesterday\b/, 'last day')
       text.gsub!(/\bnoon\b/, '12:00')
       text.gsub!(/\bmidnight\b/, '24:00')
-      text.gsub!(/\bbefore now\b/, 'past')
       text.gsub!(/\bnow\b/, 'this second')
-      text.gsub!(/\b(ago|before)\b/, 'past')
-      text.gsub!(/\bthis past\b/, 'last')
-      text.gsub!(/\bthis last\b/, 'last')
+      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')
@@ -143,6 +138,7 @@ module Chronic
     # @param [String] text The string to convert
     # @return [String] 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
 
@@ -151,7 +147,6 @@ module Chronic
     # @param [Span] span
     # @return [Time]
     def guess(span)
-      return nil if span.nil?
       if span.width > 1
         span.begin + (span.width / 2)
       else
@@ -174,6 +169,7 @@ module Chronic
 
         :date => [
           Handler.new([:repeater_day_name, :repeater_month_name, :scalar_day, :repeater_time, :separator_slash_or_dash?, :time_zone, :scalar_year], :handle_rdn_rmn_sd_t_tz_sy),
+          Handler.new([:scalar_year, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :scalar_day, :repeater_time, :time_zone], :handle_sy_sm_sd_t_tz),
           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),
@@ -222,19 +218,65 @@ module Chronic
       when :middle
         @definitions[:endian] = endians
       else
-        raise InvalidArgumentException, "Unknown endian option '#{endian}'"
+        raise ArgumentError, "Unknown endian option '#{endian}'"
       end
 
       @definitions
     end
 
+    # Construct a time Object
+    #
+    # @return [Time]
+    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
 
     def tokenize(text, options)
       text = pre_normalize(text)
       tokens = text.split(' ').map { |word| Token.new(word) }
       [Repeater, Grabber, Pointer, Scalar, Ordinal, Separator, TimeZone].each do |tok|
-        tokens = tok.scan(tokens, options)
+        tok.scan(tokens, options)
       end
       tokens.select { |token| token.tagged? }
     end
@@ -242,35 +284,23 @@ module Chronic
     def tokens_to_span(tokens, options)
       definitions = definitions(options)
 
-      (definitions[:date] + definitions[:endian]).each do |handler|
-        if handler.match(tokens, definitions)
-          puts "-date" if Chronic.debug
-          good_tokens = tokens.select { |o| !o.get_tag Separator }
-          return Handlers.send(handler.handler_method, good_tokens, options)
-        end
-      end
+      definitions.each do |type, handlers|
+        handlers.each do |handler|
+          next unless handler.match(tokens, definitions)
 
-      definitions[:anchor].each do |handler|
-        if handler.match(tokens, definitions)
-          puts "-anchor" if Chronic.debug
-          good_tokens = tokens.select { |o| !o.get_tag Separator }
-          return Handlers.send(handler.handler_method, good_tokens, options)
-        end
-      end
+          good_tokens = case type
+          when :date, :endian, :anchor
+            tokens.reject { |o| o.get_tag Separator }
+          when :arrow
+            tokens.reject { |o| o.get_tag(SeparatorAt) || o.get_tag(SeparatorSlashOrDash) || o.get_tag(SeparatorComma) }
+          else
+            tokens
+          end
 
-      definitions[:arrow].each do |handler|
-        if handler.match(tokens, definitions)
-          puts "-arrow" if Chronic.debug
-          good_tokens = tokens.reject { |o| o.get_tag(SeparatorAt) || o.get_tag(SeparatorSlashOrDash) || o.get_tag(SeparatorComma) }
-          return Handlers.send(handler.handler_method, good_tokens, options)
-        end
-      end
+          if handler.handler_method
+            return handler.invoke(type, good_tokens, options)
+          end
 
-      definitions[:narrow].each do |handler|
-        if handler.match(tokens, definitions)
-          puts "-narrow" if Chronic.debug
-          good_tokens = tokens.select { |o| !o.get_tag Separator }
-          return Handlers.send(handler.handler_method, tokens, options)
         end
       end
 
@@ -283,9 +313,4 @@ module Chronic
   # Internal exception
   class ChronicPain < Exception
   end
-
-  # This exception is raised if an invalid argument is provided to
-  # any of Chronic's methods
-  class InvalidArgumentException < Exception
-  end
 end

data/lib/chronic/handler.rb

@@ -0,0 +1,90 @@
+module Chronic
+  class Handler
+
+    # @return [Array] A list of patterns
+    attr_reader :pattern
+
+    # @return [Symbol] The method which handles this list of patterns.
+    #   This method should exist inside the {Handlers} module
+    attr_reader :handler_method
+
+    # @param [Array]  pattern A list of patterns to match tokens against
+    # @param [Symbol] handler_method The method to be invoked when patterns
+    #   are matched. This method should exist inside the {Handlers} module
+    def initialize(pattern, handler_method)
+      @pattern = pattern
+      @handler_method = handler_method
+    end
+
+    # @param [Array] tokens
+    # @param [Hash]  definitions
+    # @return [Boolean]
+    # @see Chronic.tokens_to_span
+    def match(tokens, definitions)
+      token_index = 0
+
+      @pattern.each do |element|
+        name = element.to_s
+        optional = name[-1, 1] == '?'
+        name = name.chop if optional
+
+        case element
+        when Symbol
+          if tags_match?(name, tokens, token_index)
+            token_index += 1
+            next
+          else
+            if optional
+              next
+            else
+              return false
+            end
+          end
+        when String
+          return true if optional && token_index == tokens.size
+
+          if definitions.key?(name.to_sym)
+            sub_handlers = definitions[name.to_sym]
+          else
+            raise ChronicPain, "Invalid subset #{name} specified"
+          end
+
+          sub_handlers.each do |sub_handler|
+            return true if sub_handler.match(tokens[token_index..tokens.size], definitions)
+          end
+        else
+          raise ChronicPain, "Invalid match type: #{element.class}"
+        end
+      end
+
+      return false if token_index != tokens.size
+      return true
+    end
+
+    def invoke(type, tokens, options)
+      if Chronic.debug
+        puts "-#{type}"
+        puts "Handler: #{@handler_method}"
+      end
+
+      Handlers.send(@handler_method, tokens, options)
+    end
+
+    # @param [Handler]  The handler to compare
+    # @return [Boolean] True if these handlers match
+    def ==(other)
+      @pattern == other.pattern
+    end
+
+    private
+
+    def tags_match?(name, tokens, token_index)
+      klass = Chronic.const_get(name.to_s.gsub(/(?:^|_)(.)/) { $1.upcase })
+
+      if tokens[token_index]
+        !tokens[token_index].tags.select { |o| o.kind_of?(klass) }.empty?
+      end
+    end
+
+  end
+end

data/lib/chronic/handlers.rb

@@ -3,50 +3,81 @@ module Chronic
     module_function
 
     # Handle month/day
-    def handle_m_d(month, day, time_tokens, options) #:nodoc:
+    def handle_m_d(month, day, time_tokens, options)
       month.start = Chronic.now
       span = month.this(options[:context])
-
-      day_start = Chronic.time_class.local(span.begin.year, span.begin.month, day)
+      year, month = span.begin.year, span.begin.month
+      day_start = Chronic.time_class.local(year, month, day)
 
       day_or_time(day_start, time_tokens, options)
     end
 
     # Handle repeater-month-name/scalar-day
-    def handle_rmn_sd(tokens, options) #:nodoc:
-      handle_m_d(tokens[0].get_tag(RepeaterMonthName), tokens[1].get_tag(ScalarDay).type, tokens[2..tokens.size], options)
+    def handle_rmn_sd(tokens, options)
+      month = tokens[0].get_tag(RepeaterMonthName)
+      day = tokens[1].get_tag(ScalarDay).type
+
+      return if month_overflow?(Chronic.now.year, month.index, day)
+
+      handle_m_d(month, day, tokens[2..tokens.size], options)
     end
 
     # Handle repeater-month-name/scalar-day with separator-on
-    def handle_rmn_sd_on(tokens, options) #:nodoc:
+    def handle_rmn_sd_on(tokens, options)
       if tokens.size > 3
-        handle_m_d(tokens[2].get_tag(RepeaterMonthName), tokens[3].get_tag(ScalarDay).type, tokens[0..1], options)
+        month = tokens[2].get_tag(RepeaterMonthName)
+        day = tokens[3].get_tag(ScalarDay).type
+        token_range = 0..1
       else
-        handle_m_d(tokens[1].get_tag(RepeaterMonthName), tokens[2].get_tag(ScalarDay).type, tokens[0..0], options)
+        month = tokens[1].get_tag(RepeaterMonthName)
+        day = tokens[2].get_tag(ScalarDay).type
+        token_range = 0..0
       end
+
+      return if month_overflow?(Chronic.now.year, month.index, day)
+
+      handle_m_d(month, day, tokens[token_range], options)
     end
 
     # Handle repeater-month-name/ordinal-day
-    def handle_rmn_od(tokens, options) #:nodoc:
-      handle_m_d(tokens[0].get_tag(RepeaterMonthName), tokens[1].get_tag(OrdinalDay).type, tokens[2..tokens.size], options)
+    def handle_rmn_od(tokens, options)
+      month = tokens[0].get_tag(RepeaterMonthName)
+      day = tokens[1].get_tag(OrdinalDay).type
+
+      return if month_overflow?(Chronic.now.year, month.index, day)
+
+      handle_m_d(month, day, tokens[2..tokens.size], options)
     end
 
     # Handle ordinal-day/repeater-month-name
-    def handle_od_rmn(tokens, options) #:nodoc:
-      handle_m_d(tokens[1].get_tag(RepeaterMonthName), tokens[0].get_tag(OrdinalDay).type, tokens[2..tokens.size], options)
+    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)
+
+      handle_m_d(month, day, tokens[2..tokens.size], options)
     end
 
     # Handle repeater-month-name/ordinal-day with separator-on
-    def handle_rmn_od_on(tokens, options) #:nodoc:
+    def handle_rmn_od_on(tokens, options)
       if tokens.size > 3
-        handle_m_d(tokens[2].get_tag(RepeaterMonthName), tokens[3].get_tag(OrdinalDay).type, tokens[0..1], options)
+        month = tokens[2].get_tag(RepeaterMonthName)
+        day = tokens[3].get_tag(OrdinalDay).type
+        token_range = 0..1
       else
-        handle_m_d(tokens[1].get_tag(RepeaterMonthName), tokens[2].get_tag(OrdinalDay).type, tokens[0..0], options)
+        month = tokens[1].get_tag(RepeaterMonthName)
+        day = tokens[2].get_tag(OrdinalDay).type
+        token_range = 0..0
       end
+
+      return if month_overflow?(Chronic.now.year, month.index, day)
+
+      handle_m_d(month, day, tokens[token_range], options)
     end
 
     # Handle repeater-month-name/scalar-year
-    def handle_rmn_sy(tokens, options) #:nodoc:
+    def handle_rmn_sy(tokens, options)
       month = tokens[0].get_tag(RepeaterMonthName).index
       year = tokens[1].get_tag(ScalarYear).type
 
@@ -59,26 +90,34 @@ module Chronic
       end
 
       begin
-        Span.new(Chronic.time_class.local(year, month), Chronic.time_class.local(next_month_year, next_month_month))
+        end_time = Chronic.time_class.local(next_month_year, next_month_month)
+        Span.new(Chronic.time_class.local(year, month), end_time)
       rescue ArgumentError
         nil
       end
     end
 
-    # Handle generic timestamp
-    def handle_rdn_rmn_sd_t_tz_sy(tokens, options) #:nodoc:
+    # 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)
       t = Chronic.time_class.parse(options[:text])
       Span.new(t, t + 1)
     end
 
     # Handle repeater-month-name/scalar-day/scalar-year
-    def handle_rmn_sd_sy(tokens, options) #:nodoc:
+    def handle_rmn_sd_sy(tokens, options)
       month = tokens[0].get_tag(RepeaterMonthName).index
       day = tokens[1].get_tag(ScalarDay).type
       year = tokens[2].get_tag(ScalarYear).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)
@@ -88,13 +127,14 @@ module Chronic
     end
 
     # Handle repeater-month-name/ordinal-day/scalar-year
-    def handle_rmn_od_sy(tokens, options) #:nodoc:
+    def handle_rmn_od_sy(tokens, options)
       month = tokens[0].get_tag(RepeaterMonthName).index
       day = tokens[1].get_tag(OrdinalDay).type
       year = tokens[2].get_tag(ScalarYear).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)
@@ -104,13 +144,14 @@ module Chronic
     end
 
     # Handle oridinal-day/repeater-month-name/scalar-year
-    def handle_od_rmn_sy(tokens, options) #:nodoc:
+    def handle_od_rmn_sy(tokens, options)
       day = tokens[0].get_tag(OrdinalDay).type
       month = tokens[1].get_tag(RepeaterMonthName).index
       year = tokens[2].get_tag(ScalarYear).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)
@@ -120,22 +161,23 @@ module Chronic
     end
 
     # Handle scalar-day/repeater-month-name/scalar-year
-    def handle_sd_rmn_sy(tokens, options) #:nodoc:
+    def handle_sd_rmn_sy(tokens, options)
       new_tokens = [tokens[1], tokens[0], tokens[2]]
       time_tokens = tokens.last(tokens.size - 3)
       handle_rmn_sd_sy(new_tokens + time_tokens, options)
     end
 
     # Handle scalar-month/scalar-day/scalar-year (endian middle)
-    def handle_sm_sd_sy(tokens, options) #:nodoc:
+    def handle_sm_sd_sy(tokens, options)
       month = tokens[0].get_tag(ScalarMonth).type
       day = tokens[1].get_tag(ScalarDay).type
       year = tokens[2].get_tag(ScalarYear).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) #:nodoc:
+        day_start = Chronic.time_class.local(year, month, day)
         day_or_time(day_start, time_tokens, options)
       rescue ArgumentError
         nil
@@ -143,21 +185,21 @@ module Chronic
     end
 
     # Handle scalar-day/scalar-month/scalar-year (endian little)
-    def handle_sd_sm_sy(tokens, options) #:nodoc:
+    def handle_sd_sm_sy(tokens, options)
       new_tokens = [tokens[1], tokens[0], tokens[2]]
       time_tokens = tokens.last(tokens.size - 3)
       handle_sm_sd_sy(new_tokens + time_tokens, options)
     end
 
     # Handle scalar-year/scalar-month/scalar-day
-    def handle_sy_sm_sd(tokens, options) #:nodoc:
+    def handle_sy_sm_sd(tokens, options)
       new_tokens = [tokens[1], tokens[2], tokens[0]]
       time_tokens = tokens.last(tokens.size - 3)
       handle_sm_sd_sy(new_tokens + time_tokens, options)
     end
 
     # Handle scalar-month/scalar-year
-    def handle_sm_sy(tokens, options) #:nodoc:
+    def handle_sm_sy(tokens, options)
       month = tokens[0].get_tag(ScalarMonth).type
       year = tokens[1].get_tag(ScalarYear).type
 
@@ -170,7 +212,8 @@ module Chronic
       end
 
       begin
-        Span.new(Chronic.time_class.local(year, month), Chronic.time_class.local(next_month_year, next_month_month))
+        end_time = Chronic.time_class.local(next_month_year, next_month_month)
+        Span.new(Chronic.time_class.local(year, month), end_time)
       rescue ArgumentError
         nil
       end
@@ -179,13 +222,13 @@ module Chronic
     # anchors
 
     # Handle repeaters
-    def handle_r(tokens, options) #:nodoc:
+    def handle_r(tokens, options)
       dd_tokens = dealias_and_disambiguate_times(tokens, options)
       get_anchor(dd_tokens, options)
     end
 
     # Handle repeater/grabber/repeater
-    def handle_r_g_r(tokens, options) #:nodoc:
+    def handle_r_g_r(tokens, options)
       new_tokens = [tokens[1], tokens[0], tokens[2]]
       handle_r(new_tokens, options)
     end
@@ -193,7 +236,7 @@ module Chronic
     # arrows
 
     # Handle scalar/repeater/pointer helper
-    def handle_srp(tokens, span, options) #:nodoc:
+    def handle_srp(tokens, span, options)
       distance = tokens[0].get_tag(Scalar).type
       repeater = tokens[1].get_tag(Repeater)
       pointer = tokens[2].get_tag(Pointer).type
@@ -202,7 +245,7 @@ module Chronic
     end
 
     # Handle scalar/repeater/pointer
-    def handle_s_r_p(tokens, options) #:nodoc:
+    def handle_s_r_p(tokens, options)
       repeater = tokens[1].get_tag(Repeater)
       span = Span.new(Chronic.now, Chronic.now + 1)
 
@@ -210,13 +253,13 @@ module Chronic
     end
 
     # Handle pointer/scalar/repeater
-    def handle_p_s_r(tokens, options) #:nodoc:
+    def handle_p_s_r(tokens, options)
       new_tokens = [tokens[1], tokens[2], tokens[0]]
       handle_s_r_p(new_tokens, options)
     end
 
     # Handle scalar/repeater/pointer/anchor
-    def handle_s_r_p_a(tokens, options) #:nodoc:
+    def handle_s_r_p_a(tokens, options)
       anchor_span = get_anchor(tokens[3..tokens.size - 1], options)
       handle_srp(tokens, anchor_span, options)
     end
@@ -224,29 +267,32 @@ module Chronic
     # narrows
 
     # Handle oridinal repeaters
-    def handle_orr(tokens, outer_span, options) #:nodoc:
+    def handle_orr(tokens, outer_span, options)
       repeater = tokens[1].get_tag(Repeater)
       repeater.start = outer_span.begin - 1
       ordinal = tokens[0].get_tag(Ordinal).type
       span = nil
+
       ordinal.times do
         span = repeater.next(:future)
+
         if span.begin > outer_span.end
           span = nil
           break
         end
       end
+
       span
     end
 
     # Handle ordinal/repeater/separator/repeater
-    def handle_o_r_s_r(tokens, options) #:nodoc:
+    def handle_o_r_s_r(tokens, options)
       outer_span = get_anchor([tokens[3]], options)
       handle_orr(tokens[0..1], outer_span, options)
     end
 
     # Handle ordinal/repeater/grabber/repeater
-    def handle_o_r_g_r(tokens, options) #:nodoc:
+    def handle_o_r_g_r(tokens, options)
       outer_span = get_anchor(tokens[2..3], options)
       handle_orr(tokens[0..1], outer_span, options)
     end
@@ -264,7 +310,7 @@ module Chronic
       end
     end
 
-    def get_anchor(tokens, options) #:nodoc:
+    def get_anchor(tokens, options)
       grabber = Grabber.new(:this)
       pointer = :future
 
@@ -272,58 +318,60 @@ module Chronic
       repeaters.size.times { tokens.pop }
 
       if tokens.first && tokens.first.get_tag(Grabber)
-        grabber = tokens.first.get_tag(Grabber)
-        tokens.pop
+        grabber = tokens.shift.get_tag(Grabber)
       end
 
       head = repeaters.shift
       head.start = Chronic.now
 
       case grabber.type
-        when :last
-          outer_span = head.next(:past)
-        when :this
-          if options[:context] != :past and repeaters.size > 0
-            outer_span = head.this(:none)
-          else
-            outer_span = head.this(options[:context])
-          end
-        when :next
-          outer_span = head.next(:future)
-        else raise(ChronicPain, "Invalid grabber")
+      when :last
+        outer_span = head.next(:past)
+      when :this
+        if options[:context] != :past and repeaters.size > 0
+          outer_span = head.this(:none)
+        else
+          outer_span = head.this(options[:context])
+        end
+      when :next
+        outer_span = head.next(:future)
+      else
+        raise ChronicPain, "Invalid grabber"
       end
 
       puts "--#{outer_span}" if Chronic.debug
       find_within(repeaters, outer_span, pointer)
     end
 
-    def get_repeaters(tokens) #:nodoc:
-      repeaters = []
-      tokens.each do |token|
-        if t = token.get_tag(Repeater)
-          repeaters << t
-        end
+    def get_repeaters(tokens)
+      tokens.map { |token| token.get_tag(Repeater) }.compact.sort.reverse
+    end
+
+    def month_overflow?(year, month, day)
+      if Date.leap?(year)
+        day > RepeaterMonth::MONTH_DAYS_LEAP[month - 1]
+      else
+        day > RepeaterMonth::MONTH_DAYS[month - 1]
       end
-      repeaters.sort.reverse
     end
 
     # Recursively finds repeaters within other repeaters.
     # Returns a Span representing the innermost time span
     # or nil if no repeater union could be found
-    def find_within(tags, span, pointer) #:nodoc:
+    def find_within(tags, span, pointer)
       puts "--#{span}" if Chronic.debug
       return span if tags.empty?
 
-      head, *rest = tags
-      head.start = pointer == :future ? span.begin : span.end
+      head = tags.shift
+      head.start = (pointer == :future ? span.begin : span.end)
       h = head.this(:none)
 
       if span.cover?(h.begin) || span.cover?(h.end)
-        find_within(rest, h, pointer)
+        find_within(tags, h, pointer)
       end
     end
 
-    def dealias_and_disambiguate_times(tokens, options) #:nodoc:
+    def dealias_and_disambiguate_times(tokens, options)
       # handle aliases of am/pm
       # 5:00 in the morning -> 5:00 am
       # 7:00 in the evening -> 7:00 pm
@@ -344,15 +392,16 @@ module Chronic
         end
       end
 
-      if (day_portion_index && time_index)
+      if day_portion_index && time_index
         t1 = tokens[day_portion_index]
         t1tag = t1.get_tag(RepeaterDayPortion)
 
-        if [:morning].include?(t1tag.type)
+        case t1tag.type
+        when :morning
           puts '--morning->am' if Chronic.debug
           t1.untag(RepeaterDayPortion)
           t1.tag(RepeaterDayPortion.new(:am))
-        elsif [:afternoon, :evening, :night].include?(t1tag.type)
+        when :afternoon, :evening, :night
           puts "--#{t1tag.type}->pm" if Chronic.debug
           t1.untag(RepeaterDayPortion)
           t1.tag(RepeaterDayPortion.new(:pm))
@@ -361,17 +410,21 @@ module Chronic
 
       # handle ambiguous times if :ambiguous_time_range is specified
       if options[:ambiguous_time_range] != :none
-        ttokens = []
-        tokens.each_with_index do |t0, i|
-          ttokens << t0
-          t1 = tokens[i + 1]
-          if t0.get_tag(RepeaterTime) && t0.get_tag(RepeaterTime).type.ambiguous? && (!t1 || !t1.get_tag(RepeaterDayPortion))
+        ambiguous_tokens = []
+
+        tokens.each_with_index do |token, i|
+          ambiguous_tokens << token
+          next_token = tokens[i + 1]
+
+          if token.get_tag(RepeaterTime) && token.get_tag(RepeaterTime).type.ambiguous? && (!next_token || !next_token.get_tag(RepeaterDayPortion))
             distoken = Token.new('disambiguator')
+
             distoken.tag(RepeaterDayPortion.new(options[:ambiguous_time_range]))
-            ttokens << distoken
+            ambiguous_tokens << distoken
           end
         end
-        tokens = ttokens
+
+        tokens = ambiguous_tokens
       end
 
       tokens
@@ -379,65 +432,4 @@ module Chronic
 
   end
 
-  class Handler
-    # @return [Array] A list of patterns
-    attr_accessor :pattern
-
-    # @return [Symbol] The method which handles this list of patterns.
-    #   This method should exist inside the {Handlers} module
-    attr_accessor :handler_method
-
-    # @param [Array]  pattern A list of patterns to match tokens against
-    # @param [Symbol] handler_method The method to be invoked when patterns
-    #   are matched. This method should exist inside the {Handlers} module
-    def initialize(pattern, handler_method)
-      @pattern = pattern
-      @handler_method = handler_method
-    end
-
-    # @param [#to_s]  The snake_case name representing a Chronic constant
-    # @return [Class] The class represented by `name`
-    # @raise [NameError] Raises if this constant could not be found
-    def constantize(name)
-      Chronic.const_get name.to_s.gsub(/(^|_)(.)/) { $2.upcase }
-    end
-
-    # @param [Array] tokens
-    # @param [Hash]  definitions
-    # @return [Boolean]
-    # @see Chronic.tokens_to_span
-    def match(tokens, definitions)
-      token_index = 0
-      @pattern.each do |element|
-        name = element.to_s
-        optional = name[-1, 1] == '?'
-        name = name.chop if optional
-        if element.instance_of? Symbol
-          klass = constantize(name)
-          match = tokens[token_index] && !tokens[token_index].tags.select { |o| o.kind_of?(klass) }.empty?
-          return false if !match && !optional
-          (token_index += 1; next) if match
-          next if !match && optional
-        elsif element.instance_of? String
-          return true if optional && token_index == tokens.size
-          sub_handlers = definitions[name.intern] || raise(ChronicPain, "Invalid subset #{name} specified")
-          sub_handlers.each do |sub_handler|
-            return true if sub_handler.match(tokens[token_index..tokens.size], definitions)
-          end
-          return false
-        else
-          raise(ChronicPain, "Invalid match type: #{element.class}")
-        end
-      end
-      return false if token_index != tokens.size
-      return true
-    end
-
-    # @param [Handler]  The handler to compare
-    # @return [Boolean] True if these handlers match
-    def ==(other)
-      @pattern == other.pattern
-    end
-  end
-
 end