slaxor-chronic 0.3.1

data/benchmark/benchmark.rb

@@ -0,0 +1,13 @@
+require 'chronic'
+require 'benchmark'
+
+print "jan 3 2010:                          "
+puts Benchmark.measure { Chronic.parse("jan 3 2010") }
+
+print "7 hours before tomorrow at midnight: "
+puts Benchmark.measure { Chronic.parse("7 hours before tomorrow at midnight") }
+
+# n = 100
+# Benchmark.bm(14) do |x|
+#   x.report("jan 3 2010:")   { for i in 1..n; Chronic.parse("jan 3 2010"); end }
+# end

data/lib/chronic.rb

@@ -0,0 +1,127 @@
+#=============================================================================
+#
+#  Name:       Chronic
+#  Author:     Tom Preston-Werner
+#  Purpose:    Parse natural language dates and times into Time or
+#              Chronic::Span objects
+#
+#=============================================================================
+
+$:.unshift File.dirname(__FILE__)     # For use/testing when no gem is installed
+
+require 'time'
+
+require 'chronic/chronic'
+require 'chronic/handlers'
+
+require 'chronic/repeater'
+require 'chronic/repeaters/repeater_year'
+require 'chronic/repeaters/repeater_season'
+require 'chronic/repeaters/repeater_season_name'
+require 'chronic/repeaters/repeater_month'
+require 'chronic/repeaters/repeater_month_name'
+require 'chronic/repeaters/repeater_fortnight'
+require 'chronic/repeaters/repeater_week'
+require 'chronic/repeaters/repeater_weekend'
+require 'chronic/repeaters/repeater_weekday'
+require 'chronic/repeaters/repeater_day'
+require 'chronic/repeaters/repeater_day_name'
+require 'chronic/repeaters/repeater_day_portion'
+require 'chronic/repeaters/repeater_hour'
+require 'chronic/repeaters/repeater_minute'
+require 'chronic/repeaters/repeater_second'
+require 'chronic/repeaters/repeater_time'
+
+require 'chronic/grabber'
+require 'chronic/pointer'
+require 'chronic/scalar'
+require 'chronic/ordinal'
+require 'chronic/separator'
+require 'chronic/time_zone'
+
+require 'chronic/numerizer/numerizer'
+
+module Chronic
+  VERSION = "0.3.0"
+
+  class << self
+    attr_accessor :debug
+    attr_accessor :time_class
+  end
+
+  self.debug = false
+  self.time_class = Time
+end
+
+# class Time
+#   def self.construct(year, month = 1, day = 1, hour = 0, minute = 0, second = 0)
+#     # extra_seconds = second > 60 ? second - 60 : 0
+#     # extra_minutes = minute > 59 ? minute - 59 : 0
+#     # extra_hours = hour > 23 ? hour - 23 : 0
+#     # extra_days = day >
+#
+#     if month > 12
+#       if month % 12 == 0
+#         year += (month - 12) / 12
+#         month = 12
+#       else
+#         year += month / 12
+#         month = month % 12
+#       end
+#     end
+#
+#     base = Time.local(year, month)
+#     puts base
+#     offset = ((day - 1) * 24 * 60 * 60) + (hour * 60 * 60) + (minute * 60) + second
+#     puts offset.to_s
+#     date = base + offset
+#     puts date
+#     date
+#   end
+# 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
+
+    # 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 = (year % 4 == 0) && !(year % 100 == 0)
+      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 = 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
+end

data/lib/chronic/chronic.rb

@@ -0,0 +1,249 @@
+module Chronic
+  class << self
+
+    # 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 <tt>:guess</tt>). If no date or time can be found,
+    # +nil+ will be returned.
+    #
+    # Options are:
+    #
+    # [<tt>:context</tt>]
+    #     <tt>:past</tt> or <tt>:future</tt> (defaults to <tt>:future</tt>)
+    #
+    #     If your string represents a birthday, you can set <tt>:context</tt> to <tt>:past</tt>
+    #     and if an ambiguous string is given, it will assume it is in the
+    #     past. Specify <tt>:future</tt> or omit to set a future context.
+    #
+    # [<tt>:now</tt>]
+    #     Time (defaults to Time.now)
+    #
+    #     By setting <tt>:now</tt> to a Time, all computations will be based off
+    #     of that time instead of Time.now. If set to nil, Chronic will use Time.now.
+    #
+    # [<tt>:guess</tt>]
+    #     +true+ or +false+ (defaults to +true+)
+    #
+    #     By default, the parser will guess a single point in time for the
+    #     given date or time. If you'd rather have the entire time span returned,
+    #     set <tt>:guess</tt> to +false+ and a Chronic::Span will be returned.
+    #
+    # [<tt>:ambiguous_time_range</tt>]
+    #     Integer or <tt>:none</tt> (defaults to <tt>6</tt> (6am-6pm))
+    #
+    #     If an Integer is given, ambiguous times (like 5:00) will be
+    #     assumed to be within the range of that time in the AM to that time
+    #     in the PM. For example, if you set it to <tt>7</tt>, then the parser will
+    #     look for the time between 7am and 7pm. In the case of 5:00, it would
+    #     assume that means 5:00pm. If <tt>:none</tt> is given, no assumption
+    #     will be made, and the first matching instance of that time will
+    #     be used.
+    def parse(text, specified_options = {})
+      @text = text
+
+      # get options and set defaults if necessary
+      default_options = {:context => :future,
+                         :now => Chronic.time_class.now,
+                         :guess => true,
+                         :ambiguous_time_range => 6,
+                         :endian_precedence => nil}
+      options = default_options.merge specified_options
+
+      # handle options that were set to nil
+      options[:context] = :future unless options[:context]
+      options[:now] = Chronic.time_class.now unless options[:context]
+      options[:ambiguous_time_range] = 6 unless options[:ambiguous_time_range]
+
+      # ensure the specified options are valid
+      specified_options.keys.each do |key|
+        default_options.keys.include?(key) || raise(InvalidArgumentException, "#{key} is not a valid option key.")
+      end
+      [:past, :future, :none].include?(options[:context]) || raise(InvalidArgumentException, "Invalid value ':#{options[:context]}' for :context specified. Valid values are :past and :future.")
+
+      # store now for later =)
+      @now = options[:now]
+
+      # put the text into a normal format to ease scanning
+      text = self.pre_normalize(text)
+
+      # get base tokens for each word
+      @tokens = self.base_tokenize(text)
+
+      # scan the tokens with each token scanner
+      [Repeater].each do |tokenizer|
+        @tokens = tokenizer.scan(@tokens, options)
+      end
+
+      [Grabber, Pointer, Scalar, Ordinal, Separator, TimeZone].each do |tokenizer|
+        @tokens = tokenizer.scan(@tokens)
+      end
+
+      # strip any non-tagged tokens
+      @tokens = @tokens.select { |token| token.tagged? }
+
+      if Chronic.debug
+        puts "+---------------------------------------------------"
+        puts "| " + @tokens.to_s
+        puts "+---------------------------------------------------"
+      end
+
+      # do the heavy lifting
+      begin
+        span = self.tokens_to_span(@tokens, options)
+      rescue
+        raise
+        return nil
+      end
+
+      # guess a time within a span if required
+      if options[:guess]
+        return self.guess(span)
+      else
+        return span
+      end
+    end
+
+    # Clean up the specified input text by stripping unwanted characters,
+    # converting idioms to their canonical form, converting number words
+    # to numbers (three => 3), and converting ordinal words to numeric
+    # 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!(/ \-(\d{4})\b/, ' tzminus\1')
+      normalized_text.gsub!(/([\/\-\,\@])/) { ' ' + $1 + ' ' }
+      normalized_text.gsub!(/\btoday\b/, 'this day')
+      normalized_text.gsub!(/\btomm?orr?ow\b/, 'next day')
+      normalized_text.gsub!(/\byesterday\b/, 'last day')
+      normalized_text.gsub!(/\bnoon\b/, '12:00')
+      normalized_text.gsub!(/\bmidnight\b/, '24:00')
+      normalized_text.gsub!(/\bbefore now\b/, 'past')
+      normalized_text.gsub!(/\bnow\b/, 'this second')
+      normalized_text.gsub!(/\b(ago|before)\b/, 'past')
+      normalized_text.gsub!(/\bthis past\b/, 'last')
+      normalized_text.gsub!(/\bthis last\b/, 'last')
+      normalized_text.gsub!(/\b(?:in|during) the (morning)\b/, '\1')
+      normalized_text.gsub!(/\b(?:in the|during the|at) (afternoon|evening|night)\b/, '\1')
+      normalized_text.gsub!(/\btonight\b/, 'this night')
+      normalized_text.gsub!(/\b\d+:?\d*[ap]\b/,'\0m')
+      normalized_text.gsub!(/(\d)([ap]m|oclock)\b/, '\1 \2')
+      normalized_text.gsub!(/\b(hence|after|from)\b/, 'future')
+      normalized_text = numericize_ordinals(normalized_text)
+    end
+
+    # Convert number words to numbers (three => 3)
+    def numericize_numbers(text) #:nodoc:
+      Numerizer.numerize(text)
+    end
+
+    # Convert ordinal words to numeric ordinals (third => 3rd)
+    def numericize_ordinals(text) #:nodoc:
+      text
+    end
+
+    # Split the text on spaces and convert each word into
+    # a Token
+    def base_tokenize(text) #:nodoc:
+      text.split(' ').map { |word| Token.new(word) }
+    end
+
+    # Guess a specific time within the given span
+    def guess(span) #:nodoc:
+      return nil if span.nil?
+      if span.width > 1
+        span.begin + (span.width / 2)
+      else
+        span.begin
+      end
+    end
+  end
+
+  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 = @tags.select { |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)
+      matches = @tags.select { |m| m.kind_of? tag_class }
+      #matches.size < 2 || raise("Multiple identical tags found")
+      return matches.first
+    end
+
+    # Print this Token in a pretty way
+    def to_s
+      @word << '(' << @tags.join(', ') << ') '
+    end
+  end
+
+  # 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
+  end
+
+  # 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
+  end
+
+  # Internal exception
+  class ChronicPain < Exception #:nodoc:
+
+  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/grabber.rb

@@ -0,0 +1,26 @@
+#module Chronic
+
+  class Chronic::Grabber < Chronic::Tag #:nodoc:
+    def self.scan(tokens)
+      tokens.each_index do |i|
+        if t = self.scan_for_all(tokens[i]) then tokens[i].tag(t); next end
+      end
+      tokens
+    end
+
+    def self.scan_for_all(token)
+      scanner = {/last/ => :last,
+                 /this/ => :this,
+                 /next/ => :next}
+      scanner.keys.each do |scanner_item|
+        return self.new(scanner[scanner_item]) if scanner_item =~ token.word
+      end
+      return nil
+    end
+
+    def to_s
+      'grabber-' << @type.to_s
+    end
+  end
+
+#end

data/lib/chronic/handlers.rb

@@ -0,0 +1,524 @@
+module Chronic
+
+  class << self
+
+    def definitions(options={}) #:nodoc:
+      options[:endian_precedence] = [:middle, :little] if options[:endian_precedence].nil?
+
+      # ensure the endian precedence is exactly two elements long
+      raise ChronicPain, "More than two elements specified for endian precedence array" unless options[:endian_precedence].length == 2
+
+      # handler for dd/mm/yyyy
+      @little_endian_handler ||= Handler.new([:scalar_day, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :scalar_year, :separator_at?, 'time?'], :handle_sd_sm_sy)
+
+      # handler for mm/dd/yyyy
+      @middle_endian_handler ||= Handler.new([:scalar_month, :separator_slash_or_dash, :scalar_day, :separator_slash_or_dash, :scalar_year, :separator_at?, 'time?'], :handle_sm_sd_sy)
+
+      # ensure we have valid endian values
+      options[:endian_precedence].each do |e|
+        raise ChronicPain, "Unknown endian type: #{e.to_s}" unless instance_variable_defined?(endian_variable_name_for(e))
+      end
+
+	    @definitions ||=
+      {:time => [Handler.new([:repeater_time, :repeater_day_portion?], nil)],
+
+       :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([:repeater_month_name, :scalar_day, :scalar_year], :handle_rmn_sd_sy),
+                 Handler.new([:repeater_month_name, :scalar_day, :scalar_year, :separator_at?, 'time?'], :handle_rmn_sd_sy),
+                 Handler.new([:repeater_month_name, :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([: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),
+                 @middle_endian_handler,
+                 @little_endian_handler,
+                 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)],
+
+       # tonight at 7pm
+       :anchor => [Handler.new([:grabber?, :repeater, :separator_at?, :repeater?, :repeater?], :handle_r),
+                   Handler.new([:grabber?, :repeater, :repeater, :separator_at?, :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([:pointer, :scalar, :repeater], :handle_p_s_r),
+                  Handler.new([:scalar, :repeater, :pointer, '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)]
+      }
+
+      apply_endian_precedences(options[:endian_precedence])
+
+      @definitions
+    end
+
+    def tokens_to_span(tokens, options) #:nodoc:
+      # maybe it's a specific date
+
+      definitions = self.definitions(options)
+      definitions[:date].each do |handler|
+        if handler.match(tokens, definitions)
+          puts "-date" if Chronic.debug
+          good_tokens = tokens.select { |o| !o.get_tag Separator }
+          return self.send(handler.handler_method, good_tokens, options)
+        end
+      end
+
+      # I guess it's not a specific date, maybe it's just an anchor
+
+      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 self.send(handler.handler_method, good_tokens, options)
+        end
+      end
+
+      # not an anchor, perhaps it's an arrow
+
+      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 self.send(handler.handler_method, good_tokens, options)
+        end
+      end
+
+      # not an arrow, let's hope it's a narrow
+
+      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 self.send(handler.handler_method, tokens, options)
+        end
+      end
+
+      # I guess you're out of luck!
+      puts "-none" if Chronic.debug
+      return nil
+    end
+
+    #--------------
+
+    def apply_endian_precedences(precedences)
+      date_defs = @definitions[:date]
+
+      # map the precedence array to indices on @definitions[:date]
+      indices = precedences.map { |e|
+        handler = instance_variable_get(endian_variable_name_for(e))
+        date_defs.index(handler)
+      }
+
+      # swap the handlers if we discover they are at odds with the desired preferences
+      swap(date_defs, indices.first, indices.last) if indices.first > indices.last
+    end
+
+    def endian_variable_name_for(e)
+      "@#{e.to_s}_endian_handler".to_sym
+    end
+
+    # exchange two elements in an array
+    def swap(arr, a, b); arr[a], arr[b] = arr[b], arr[a]; end
+
+    def day_or_time(day_start, time_tokens, options)
+      outer_span = Span.new(day_start, day_start + (24 * 60 * 60))
+
+      if !time_tokens.empty?
+        @now = outer_span.begin
+        time = get_anchor(dealias_and_disambiguate_times(time_tokens, options), options)
+        return time
+      else
+        return outer_span
+      end
+    end
+
+    #--------------
+
+    def handle_m_d(month, day, time_tokens, options) #:nodoc:
+      month.start = @now
+      span = month.this(options[:context])
+
+      day_start = Chronic.time_class.local(span.begin.year, span.begin.month, day)
+
+      day_or_time(day_start, time_tokens, options)
+    end
+
+    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)
+    end
+
+    def handle_rmn_sd_on(tokens, options) #:nodoc:
+      if tokens.size > 3
+        handle_m_d(tokens[2].get_tag(RepeaterMonthName), tokens[3].get_tag(ScalarDay).type, tokens[0..1], options)
+      else
+        handle_m_d(tokens[1].get_tag(RepeaterMonthName), tokens[2].get_tag(ScalarDay).type, tokens[0..0], options)
+      end
+    end
+
+    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)
+    end
+
+    def handle_rmn_od_on(tokens, options) #:nodoc:
+      if tokens.size > 3
+        handle_m_d(tokens[2].get_tag(RepeaterMonthName), tokens[3].get_tag(OrdinalDay).type, tokens[0..1], options)
+      else
+        handle_m_d(tokens[1].get_tag(RepeaterMonthName), tokens[2].get_tag(OrdinalDay).type, tokens[0..0], options)
+      end
+    end
+
+    def handle_rmn_sy(tokens, options) #:nodoc:
+      month = tokens[0].get_tag(RepeaterMonthName).index
+      year = tokens[1].get_tag(ScalarYear).type
+
+      if month == 12
+        next_month_year = year + 1
+        next_month_month = 1
+      else
+        next_month_year = year
+        next_month_month = month + 1
+      end
+
+      begin
+        Span.new(Chronic.time_class.local(year, month), Chronic.time_class.local(next_month_year, next_month_month))
+      rescue ArgumentError
+        nil
+      end
+    end
+
+    def handle_rdn_rmn_sd_t_tz_sy(tokens, options) #:nodoc:
+      t = Chronic.time_class.parse(@text)
+      Span.new(t, t + 1)
+    end
+
+    def handle_rmn_sd_sy(tokens, options) #:nodoc:
+      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)
+
+      begin
+        day_start = Chronic.time_class.local(year, month, day)
+        day_or_time(day_start, time_tokens, options)
+      rescue ArgumentError
+        nil
+      end
+    end
+
+    def handle_sd_rmn_sy(tokens, options) #:nodoc:
+      new_tokens = [tokens[1], tokens[0], tokens[2]]
+      time_tokens = tokens.last(tokens.size - 3)
+      self.handle_rmn_sd_sy(new_tokens + time_tokens, options)
+    end
+
+    def handle_sm_sd_sy(tokens, options) #:nodoc:
+      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)
+
+      begin
+        day_start = Chronic.time_class.local(year, month, day) #:nodoc:
+        day_or_time(day_start, time_tokens, options)
+      rescue ArgumentError
+        nil
+      end
+    end
+
+    def handle_sd_sm_sy(tokens, options) #:nodoc:
+      new_tokens = [tokens[1], tokens[0], tokens[2]]
+      time_tokens = tokens.last(tokens.size - 3)
+      self.handle_sm_sd_sy(new_tokens + time_tokens, options)
+    end
+
+    def handle_sy_sm_sd(tokens, options) #:nodoc:
+      new_tokens = [tokens[1], tokens[2], tokens[0]]
+      time_tokens = tokens.last(tokens.size - 3)
+      self.handle_sm_sd_sy(new_tokens + time_tokens, options)
+    end
+
+    def handle_sm_sy(tokens, options) #:nodoc:
+      month = tokens[0].get_tag(ScalarMonth).type
+      year = tokens[1].get_tag(ScalarYear).type
+
+      if month == 12
+        next_month_year = year + 1
+        next_month_month = 1
+      else
+        next_month_year = year
+        next_month_month = month + 1
+      end
+
+      begin
+        Span.new(Chronic.time_class.local(year, month), Chronic.time_class.local(next_month_year, next_month_month))
+      rescue ArgumentError
+        nil
+      end
+    end
+
+    # anchors
+
+    def handle_r(tokens, options) #:nodoc:
+      dd_tokens = dealias_and_disambiguate_times(tokens, options)
+      self.get_anchor(dd_tokens, options)
+    end
+
+    def handle_r_g_r(tokens, options) #:nodoc:
+      new_tokens = [tokens[1], tokens[0], tokens[2]]
+      self.handle_r(new_tokens, options)
+    end
+
+    # arrows
+
+    def handle_srp(tokens, span, options) #:nodoc:
+      distance = tokens[0].get_tag(Scalar).type
+      repeater = tokens[1].get_tag(Repeater)
+      pointer = tokens[2].get_tag(Pointer).type
+
+      repeater.offset(span, distance, pointer)
+    end
+
+    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 = self.parse("this second", :guess => false, :now => @now)
+
+      self.handle_srp(tokens, span, options)
+    end
+
+    def handle_p_s_r(tokens, options) #:nodoc:
+      new_tokens = [tokens[1], tokens[2], tokens[0]]
+      self.handle_s_r_p(new_tokens, options)
+    end
+
+    def handle_s_r_p_a(tokens, options) #:nodoc:
+      anchor_span = get_anchor(tokens[3..tokens.size - 1], options)
+      self.handle_srp(tokens, anchor_span, options)
+    end
+
+    # narrows
+
+    def handle_orr(tokens, outer_span, options) #:nodoc:
+      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
+
+    def handle_o_r_s_r(tokens, options) #:nodoc:
+      outer_span = get_anchor([tokens[3]], options)
+      handle_orr(tokens[0..1], outer_span, options)
+    end
+
+    def handle_o_r_g_r(tokens, options) #:nodoc:
+      outer_span = get_anchor(tokens[2..3], options)
+      handle_orr(tokens[0..1], outer_span, options)
+    end
+
+    # support methods
+
+    def get_anchor(tokens, options) #:nodoc:
+      grabber = Grabber.new(:this)
+      pointer = :future
+
+      repeaters = self.get_repeaters(tokens)
+      repeaters.size.times { tokens.pop }
+
+      if tokens.first && tokens.first.get_tag(Grabber)
+        grabber = tokens.first.get_tag(Grabber)
+        tokens.pop
+      end
+
+      head = repeaters.shift
+      head.start = @now
+
+      case grabber.type
+        when :last
+          outer_span = head.next(:past)
+        when :this
+          if 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
+      anchor = 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
+      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:
+      puts "--#{span}" if Chronic.debug
+      return span if tags.empty?
+
+      head, *rest = tags
+      head.start = pointer == :future ? span.begin : span.end
+      h = head.this(:none)
+
+      if span.include?(h.begin) || span.include?(h.end)
+        return find_within(rest, h, pointer)
+      else
+        return nil
+      end
+    end
+
+    def dealias_and_disambiguate_times(tokens, options) #:nodoc:
+      # handle aliases of am/pm
+      # 5:00 in the morning -> 5:00 am
+      # 7:00 in the evening -> 7:00 pm
+
+      day_portion_index = nil
+      tokens.each_with_index do |t, i|
+        if t.get_tag(RepeaterDayPortion)
+          day_portion_index = i
+          break
+        end
+      end
+
+      time_index = nil
+      tokens.each_with_index do |t, i|
+        if t.get_tag(RepeaterTime)
+          time_index = i
+          break
+        end
+      end
+
+      if (day_portion_index && time_index)
+        t1 = tokens[day_portion_index]
+        t1tag = t1.get_tag(RepeaterDayPortion)
+
+        if [:morning].include?(t1tag.type)
+          puts '--morning->am' if Chronic.debug
+          t1.untag(RepeaterDayPortion)
+          t1.tag(RepeaterDayPortion.new(:am))
+        elsif [:afternoon, :evening, :night].include?(t1tag.type)
+          puts "--#{t1tag.type}->pm" if Chronic.debug
+          t1.untag(RepeaterDayPortion)
+          t1.tag(RepeaterDayPortion.new(:pm))
+        end
+      end
+
+      # tokens.each_with_index do |t0, i|
+      #   t1 = tokens[i + 1]
+      #   if t1 && (t1tag = t1.get_tag(RepeaterDayPortion)) && t0.get_tag(RepeaterTime)
+      #     if [:morning].include?(t1tag.type)
+      #       puts '--morning->am' if Chronic.debug
+      #       t1.untag(RepeaterDayPortion)
+      #       t1.tag(RepeaterDayPortion.new(:am))
+      #     elsif [:afternoon, :evening, :night].include?(t1tag.type)
+      #       puts "--#{t1tag.type}->pm" if Chronic.debug
+      #       t1.untag(RepeaterDayPortion)
+      #       t1.tag(RepeaterDayPortion.new(:pm))
+      #     end
+      #   end
+      # end
+
+      # 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))
+            distoken = Token.new('disambiguator')
+            distoken.tag(RepeaterDayPortion.new(options[:ambiguous_time_range]))
+            ttokens << distoken
+          end
+        end
+        tokens = ttokens
+      end
+
+      tokens
+    end
+
+  end
+
+  class Handler #:nodoc:
+    attr_accessor :pattern, :handler_method
+
+    def initialize(pattern, handler_method)
+      @pattern = pattern
+      @handler_method = handler_method
+    end
+
+    def constantize(name)
+      camel = name.to_s.gsub(/(^|_)(.)/) { $2.upcase }
+      ::Chronic.module_eval(camel, __FILE__, __LINE__)
+    end
+
+    def match(tokens, definitions)
+      token_index = 0
+      @pattern.each do |element|
+        name = element.to_s
+        optional = name.reverse[0..0] == '?'
+        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
+
+    def ==(other)
+      self.pattern == other.pattern
+    end
+  end
+
+end