rizwanreza-chronic 0.0.1

data/lib/chronic/chronic.rb

@@ -0,0 +1,326 @@
+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+, +false+, +"start"+, +"middle"+, and +"end"+ (defaults to +true+)
+		#
+		#     By default, the parser will guess a single point in time for the
+		#     given date or time.  +:guess+ => +true+ or +"middle"+ will return the middle
+		#     value of the range.  If +"start"+ is specified, Chronic::Span will return the
+		#     beginning of the range.  If +"end"+ is specified, the last value in
+		#     Chronic::Span will be returned. 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 = {})
+			# strip any non-tagged tokens
+			@tokens = tokenize(text, specified_options).select { |token| token.tagged? }
+
+			if Chronic.debug
+				puts "+---------------------------------------------------"
+				puts "| " + @tokens.to_s
+				puts "+---------------------------------------------------"
+			end
+
+			options = default_options(specified_options)
+
+			# 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, options[:guess])
+			else
+				return span
+			end
+		end
+
+		def strip_tokens(text, specified_options = {})
+			# strip any tagged tokens
+			return tokenize(text, specified_options).select { |token| !token.tagged? }.map { |token| token.word }.join(' ')
+		end
+		
+		def date_string(text, specified_options = {})
+      text = pre_normalize(text)
+      date_tokens = tokenize(text).map { |token| token.word if token.tagged? }
+      return date_tokens.join(' ').strip
+	  end
+
+		# Returns an array with text tokenized by the respective classes
+		def tokenize(text, specified_options = {})
+			@text = text
+
+			options = default_options(specified_options)
+			# store now for later =)
+			@now = options[:now]
+
+			# put the text into a normal format to ease scanning
+			puts "+++ text = #{text}" if Chronic.debug
+			text = self.pre_normalize(text)
+			puts "--- text = #{text}" if Chronic.debug
+
+			# get base tokens for each word
+			@tokens = self.base_tokenize(text)
+			puts @tokens if Chronic.debug
+
+			# 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
+      
+      # remove trailing separator tokens
+      @tokens.length.times do |ix|
+        # if this is a separator token, there needs to be another tagged token next
+        if @tokens[ix].get_tag(Chronic::Separator)
+          next_token = ix + 1
+          next_token_exists_and_is_not_tagged = (@tokens[next_token] and not @tokens[next_token].tagged?)
+          next_token_does_not_exist = (not @tokens[next_token])
+          if (next_token_does_not_exist) or (next_token_exists_and_is_not_tagged)
+            @tokens[ix].tags = []
+          end
+        end
+      end
+      
+			return @tokens
+		end
+
+		def default_options(specified_options)
+			# get options and set defaults if necessary
+			default_options = {:context => :future,
+				:now => Chronic.time_class.now,
+				:guess => true,
+				:guess_how => :middle,
+				: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.")
+			["start", "middle", "end", true, false].include?(options[:guess]) || validate_percentness_of(options[:guess]) || raise(InvalidArgumentException, "Invalid value ':#{options[:guess]}' for :guess how specified. Valid values are true, false, \"start\", \"middle\", and \"end\".  true will default to \"middle\". :guess can also be a percent(0.60)")
+
+			return options
+		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
+			normalized_text = numericize_numbers(normalized_text)
+			normalized_text.gsub!(/['",]/, '')
+			normalized_text.gsub!(/(\d+\:\d+)\.(\d+)/, '\1\2')
+			normalized_text.gsub!(/ \-(\d{4})\b/, ' tzminus\1')
+			normalized_text.gsub!(/([\/\-\,\@])/) { ' ' + $1 + ' ' }
+			normalized_text.gsub!(/\btoday\b/i, 'this day')
+			normalized_text.gsub!(/\btomm?orr?ow\b/i, 'next day')
+			normalized_text.gsub!(/\byesterday\b/i, 'last day')
+			normalized_text.gsub!(/\bnoon\b/i, '12:00')
+			normalized_text.gsub!(/\bmidnight\b/i, '24:00')
+			normalized_text.gsub!(/\bbefore now\b/i, 'past')
+			normalized_text.gsub!(/\bnow\b/i, 'this second')
+			normalized_text.gsub!(/\b(ago|before)\b/i, 'past')
+			normalized_text.gsub!(/\bthis past\b/i, 'last')
+			normalized_text.gsub!(/\bthis last\b/i, 'last')
+			normalized_text.gsub!(/\b(?:in|during) the (morning)\b/i, '\1')
+			normalized_text.gsub!(/\b(?:in the|during the|at) (afternoon|evening|night)\b/i, '\1')
+			normalized_text.gsub!(/\btonight\b/i, 'this night')
+			normalized_text.gsub!(/\b\d+:?\d*[ap]\b/i,'\0m')
+			normalized_text.gsub!(/(\d)([ap]m|oclock)\b/i, '\1 \2')
+			normalized_text.gsub!(/\b(hence|after|from)\b/i, 'future')
+			normalized_text.gsub!(/\bh[ou]{0,2}rs?\b/i, 'hour')
+			#not needed - see test_parse_before_now (test_parsing.rb +726)
+			#normalized_text.gsub!(/\bbefore now\b/, 'past')
+
+			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, guess=true) #:nodoc:
+			return nil if span.nil?
+			if span.width > 1
+				# Account for a timezone difference between the start and end of the range.
+				# This most likely will happen when dealing with a Daylight Saving Time start
+				# or end day.
+				gmt_offset_diff = span.begin.gmt_offset - span.end.gmt_offset
+				case guess
+				when "start"
+					span.begin
+				when true, "middle"
+					span.begin + ((span.width - gmt_offset_diff) / 2)
+				when "end"
+					span.begin + (span.width - gmt_offset_diff)
+				else
+					span.begin + ((span.width - gmt_offset_diff) * guess)
+				end
+			else
+				span.begin
+			end
+		end
+
+		# Validates numericality of something
+		def validate_percentness_of(number) #:nodoc:
+			number.to_s.to_f == number && number >= 0 && number <= 1
+		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
+
+    unless RUBY_VERSION =~ /1\.9\./
+      alias :cover? :include?
+    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
+
+		def initialize(range_begin, range_end)
+			# Use exclusive range.
+			super(range_begin, range_end, true)
+		end
+
+		# 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/i => :last,
+			/this/i => :this,
+			/next/i => :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,549 @@
+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_month_name, :ordinal_day, :scalar_year], :handle_rmn_od_sy),
+						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, :repeater, :grabber, :repeater], :handle_r_r_g_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_sy(tokens, options) #:nodoc:
+			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)
+
+			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_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:
+			self.handle_r(tokens.values_at(1,0,2), options)
+		end
+
+		def handle_r_r_g_r(tokens, options) #:nodoc:
+			self.handle_r(tokens.values_at(2,3,0,1), 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
+
+    def in_span?(span, t)
+      t && span && t >= span.begin && t <= span.end
+    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 in_span?(span, h.begin) || in_span(span, 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