chronic 0.2.3 → 0.3.0

data/lib/chronic.rb

@@ -9,6 +9,8 @@
 
 $:.unshift File.dirname(__FILE__)     # For use/testing when no gem is installed
 
+require 'time'
+
 require 'chronic/chronic'
 require 'chronic/handlers'
 
@@ -21,6 +23,7 @@ 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'
@@ -36,19 +39,18 @@ require 'chronic/ordinal'
 require 'chronic/separator'
 require 'chronic/time_zone'
 
-require 'numerizer/numerizer'
+require 'chronic/numerizer/numerizer'
 
 module Chronic
-  VERSION = "0.2.3"
-  
-  def self.debug; false; end
-end
+  VERSION = "0.3.0"
 
-alias p_orig p
+  class << self
+    attr_accessor :debug
+    attr_accessor :time_class
+  end
 
-def p(val)
-  p_orig val
-  puts
+  self.debug = false
+  self.time_class = Time
 end
 
 # class Time
@@ -56,8 +58,8 @@ end
 #     # extra_seconds = second > 60 ? second - 60 : 0
 #     # extra_minutes = minute > 59 ? minute - 59 : 0
 #     # extra_hours = hour > 23 ? hour - 23 : 0
-#     # extra_days = day > 
-#     
+#     # extra_days = day >
+#
 #     if month > 12
 #       if month % 12 == 0
 #         year += (month - 12) / 12
@@ -67,7 +69,7 @@ end
 #         month = month % 12
 #       end
 #     end
-#     
+#
 #     base = Time.local(year, month)
 #     puts base
 #     offset = ((day - 1) * 24 * 60 * 60) + (hour * 60 * 60) + (minute * 60) + second
@@ -84,17 +86,17 @@ class Time
       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)")
@@ -109,7 +111,7 @@ class Time
         day = day % days_this_month
       end
     end
-    
+
     if month > 12
       if month % 12 == 0
         year += (month - 12) / 12
@@ -119,7 +121,7 @@ class Time
         month = month % 12
       end
     end
-    
-    Time.local(year, month, day, hour, minute, second)
+
+    Chronic.time_class.local(year, month, day, hour, minute, second)
   end
-end
+end

data/lib/chronic/chronic.rb

@@ -1,8 +1,8 @@
 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 
+    # 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.
     #
@@ -11,15 +11,15 @@ module Chronic
     # [<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 
+    #     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
+    #     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+)
@@ -27,58 +27,66 @@ module Chronic
     #     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 
+    #     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 
+    #     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 => Time.now,
+                         :now => Chronic.time_class.now,
                          :guess => true,
-                         :ambiguous_time_range => 6}
+                         :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)
@@ -86,7 +94,7 @@ module Chronic
         raise
         return nil
       end
-      
+
       # guess a time within a span if required
       if options[:guess]
         return self.guess(span)
@@ -94,7 +102,7 @@ module Chronic
         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
@@ -102,7 +110,8 @@ module Chronic
     def pre_normalize(text) #:nodoc:
       normalized_text = text.to_s.downcase
       normalized_text = numericize_numbers(normalized_text)
-      normalized_text.gsub!(/['"\.]/, '')
+      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')
@@ -117,27 +126,28 @@ module Chronic
       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!(/(?=\w)([ap]m|oclock)\b/, ' \1')
+      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?
@@ -148,64 +158,64 @@ module Chronic
       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   
+  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 
+
+    # 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 
+
+    # 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 << ')'
@@ -216,24 +226,24 @@ module Chronic
   # 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
+end

data/lib/chronic/grabber.rb

@@ -7,7 +7,7 @@
       end
       tokens
     end
-    
+
     def self.scan_for_all(token)
       scanner = {/last/ => :last,
                  /this/ => :this,
@@ -17,7 +17,7 @@
       end
       return nil
     end
-    
+
     def to_s
       'grabber-' << @type.to_s
     end

data/lib/chronic/handlers.rb

@@ -1,90 +1,133 @@
 module Chronic
 
-	class << self
-	  
-	  def definitions #:nodoc:
-	    @definitions ||= 
+  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, :time_zone, :scalar_year], :handle_rdn_rmn_sd_t_tz_sy),
+
+       :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),
-                 Handler.new([:scalar_month, :separator_slash_or_dash, :scalar_day, :separator_slash_or_dash, :scalar_year, :separator_at?, 'time?'], :handle_sm_sd_sy),
-                 Handler.new([:scalar_day, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :scalar_year, :separator_at?, 'time?'], :handle_sd_sm_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:                   
+
+    def tokens_to_span(tokens, options) #:nodoc:
       # maybe it's a specific date
-      
-      self.definitions[:date].each do |handler|
-        if handler.match(tokens, self.definitions)
+
+      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
-            
-      self.definitions[:anchor].each do |handler|
-        if handler.match(tokens, self.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 self.send(handler.handler_method, good_tokens, options)
         end
       end
-            
+
       # not an anchor, perhaps it's an arrow
-      
-      self.definitions[:arrow].each do |handler|
-        if handler.match(tokens, self.definitions)
+
+      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
-      
-      self.definitions[:narrow].each do |handler|
-        if handler.match(tokens, self.definitions)
+
+      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)
@@ -93,30 +136,46 @@ module Chronic
         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 = Time.local(span.begin.year, span.begin.month, day)
-      
+
+      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
@@ -124,79 +183,71 @@ module Chronic
         next_month_year = year
         next_month_month = month + 1
       end
-      
+
       begin
-        Span.new(Time.local(year, month), Time.local(next_month_year, next_month_month))
+        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:
-      month = tokens[1].get_tag(RepeaterMonthName).index
-      day = tokens[2].get_tag(ScalarDay).type
-      year = tokens[5].get_tag(ScalarYear).type
-      
-      begin
-        day_start = Time.local(year, month, day)
-        day_or_time(day_start, [tokens[3]], options)
-      rescue ArgumentError
-        nil
-      end
+      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 = Time.local(year, month, day)
+        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 = Time.local(year, month, day) #:nodoc:
+        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
@@ -204,40 +255,40 @@ module Chronic
         next_month_year = year
         next_month_month = month + 1
       end
-      
+
       begin
-        Span.new(Time.local(year, month), Time.local(next_month_year, next_month_month))
+        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 = 
+
+      # span =
       # case true
       # when [RepeaterYear, RepeaterSeason, RepeaterSeasonName, RepeaterMonth, RepeaterMonthName, RepeaterFortnight, RepeaterWeek].include?(repeater.class)
       #   self.parse("this hour", :guess => false, :now => @now)
@@ -248,24 +299,24 @@ module Chronic
       # 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
@@ -280,34 +331,34 @@ module Chronic
       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)
@@ -321,11 +372,11 @@ module Chronic
           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|
@@ -335,30 +386,30 @@ module Chronic
       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)
@@ -366,7 +417,7 @@ module Chronic
           break
         end
       end
-       
+
       time_index = nil
       tokens.each_with_index do |t, i|
         if t.get_tag(RepeaterTime)
@@ -374,11 +425,11 @@ module Chronic
           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)
@@ -389,7 +440,7 @@ module Chronic
           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)
@@ -404,7 +455,7 @@ module Chronic
       #     end
       #   end
       # end
-            
+
       # handle ambiguous times if :ambiguous_time_range is specified
       if options[:ambiguous_time_range] != :none
         ttokens = []
@@ -419,25 +470,25 @@ module Chronic
         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|
@@ -464,6 +515,10 @@ module Chronic
       return false if token_index != tokens.size
       return true
     end
+
+    def ==(other)
+      self.pattern == other.pattern
+    end
   end
-  
-end
+
+end