chronic 0.4.1 → 0.5.0

data/lib/chronic/handlers.rb

@@ -1,156 +1,10 @@
 module Chronic
+  module Handlers
+    module_function
 
-  class << self
-
-    def definitions(options={}) #:nodoc:
-      options[:endian_precedence] ||= [:middle, :little]
-      # 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, :ordinal_day, :scalar_year], :handle_rmn_od_sy),
-          Handler.new([:repeater_month_name, :scalar_day, :scalar_year, :separator_at?, 'time?'], :handle_rmn_sd_sy),
-          Handler.new([:repeater_month_name, :ordinal_day, :scalar_year, :separator_at?, 'time?'], :handle_rmn_od_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
-        get_anchor(dealias_and_disambiguate_times(time_tokens, options), options)
-      else
-        outer_span
-      end
-    end
-
-    #--------------
-
+    # Handle month/day
     def handle_m_d(month, day, time_tokens, options) #:nodoc:
-      month.start = @now
+      month.start = Chronic.now
       span = month.this(options[:context])
 
       day_start = Chronic.time_class.local(span.begin.year, span.begin.month, day)
@@ -158,10 +12,12 @@ module Chronic
       day_or_time(day_start, time_tokens, options)
     end
 
+    # Handle repeater-month-name/scalar-day
     def handle_rmn_sd(tokens, options) #:nodoc:
       handle_m_d(tokens[0].get_tag(RepeaterMonthName), tokens[1].get_tag(ScalarDay).type, tokens[2..tokens.size], options)
     end
 
+    # Handle repeater-month-name/scalar-day with separator-on
     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)
@@ -170,10 +26,17 @@ module Chronic
       end
     end
 
+    # Handle repeater-month-name/ordinal-day
     def handle_rmn_od(tokens, options) #:nodoc:
       handle_m_d(tokens[0].get_tag(RepeaterMonthName), tokens[1].get_tag(OrdinalDay).type, tokens[2..tokens.size], options)
     end
 
+    # Handle ordinal-day/repeater-month-name
+    def handle_od_rmn(tokens, options) #:nodoc:
+      handle_m_d(tokens[1].get_tag(RepeaterMonthName), tokens[0].get_tag(OrdinalDay).type, tokens[2..tokens.size], options)
+    end
+
+    # Handle repeater-month-name/ordinal-day with separator-on
     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)
@@ -182,6 +45,7 @@ module Chronic
       end
     end
 
+    # Handle repeater-month-name/scalar-year
     def handle_rmn_sy(tokens, options) #:nodoc:
       month = tokens[0].get_tag(RepeaterMonthName).index
       year = tokens[1].get_tag(ScalarYear).type
@@ -201,11 +65,13 @@ module Chronic
       end
     end
 
+    # Handle generic timestamp
     def handle_rdn_rmn_sd_t_tz_sy(tokens, options) #:nodoc:
-      t = Chronic.time_class.parse(@text)
+      t = Chronic.time_class.parse(options[:text])
       Span.new(t, t + 1)
     end
 
+    # Handle repeater-month-name/scalar-day/scalar-year
     def handle_rmn_sd_sy(tokens, options) #:nodoc:
       month = tokens[0].get_tag(RepeaterMonthName).index
       day = tokens[1].get_tag(ScalarDay).type
@@ -221,6 +87,7 @@ module Chronic
       end
     end
 
+    # Handle repeater-month-name/ordinal-day/scalar-year
     def handle_rmn_od_sy(tokens, options) #:nodoc:
       month = tokens[0].get_tag(RepeaterMonthName).index
       day = tokens[1].get_tag(OrdinalDay).type
@@ -236,12 +103,30 @@ module Chronic
       end
     end
 
+    # Handle oridinal-day/repeater-month-name/scalar-year
+    def handle_od_rmn_sy(tokens, options) #:nodoc:
+      day = tokens[0].get_tag(OrdinalDay).type
+      month = tokens[1].get_tag(RepeaterMonthName).index
+      year = tokens[2].get_tag(ScalarYear).type
+
+      time_tokens = tokens.last(tokens.size - 3)
+
+      begin
+        day_start = Chronic.time_class.local(year, month, day)
+        day_or_time(day_start, time_tokens, options)
+      rescue ArgumentError
+        nil
+      end
+    end
+
+    # Handle scalar-day/repeater-month-name/scalar-year
     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)
+      handle_rmn_sd_sy(new_tokens + time_tokens, options)
     end
 
+    # Handle scalar-month/scalar-day/scalar-year (endian middle)
     def handle_sm_sd_sy(tokens, options) #:nodoc:
       month = tokens[0].get_tag(ScalarMonth).type
       day = tokens[1].get_tag(ScalarDay).type
@@ -257,18 +142,21 @@ module Chronic
       end
     end
 
+    # Handle scalar-day/scalar-month/scalar-year (endian little)
     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)
+      handle_sm_sd_sy(new_tokens + time_tokens, options)
     end
 
+    # Handle scalar-year/scalar-month/scalar-day
     def handle_sy_sm_sd(tokens, options) #:nodoc:
       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)
+      handle_sm_sd_sy(new_tokens + time_tokens, options)
     end
 
+    # Handle scalar-month/scalar-year
     def handle_sm_sy(tokens, options) #:nodoc:
       month = tokens[0].get_tag(ScalarMonth).type
       year = tokens[1].get_tag(ScalarYear).type
@@ -290,18 +178,21 @@ module Chronic
 
     # anchors
 
+    # Handle repeaters
     def handle_r(tokens, options) #:nodoc:
       dd_tokens = dealias_and_disambiguate_times(tokens, options)
-      self.get_anchor(dd_tokens, options)
+      get_anchor(dd_tokens, options)
     end
 
+    # Handle repeater/grabber/repeater
     def handle_r_g_r(tokens, options) #:nodoc:
       new_tokens = [tokens[1], tokens[0], tokens[2]]
-      self.handle_r(new_tokens, options)
+      handle_r(new_tokens, options)
     end
 
     # arrows
 
+    # Handle scalar/repeater/pointer helper
     def handle_srp(tokens, span, options) #:nodoc:
       distance = tokens[0].get_tag(Scalar).type
       repeater = tokens[1].get_tag(Repeater)
@@ -310,38 +201,29 @@ module Chronic
       repeater.offset(span, distance, pointer)
     end
 
+    # Handle scalar/repeater/pointer
     def handle_s_r_p(tokens, options) #:nodoc:
       repeater = tokens[1].get_tag(Repeater)
+      span = Span.new(Chronic.now, Chronic.now + 1)
 
-      # 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 = Span.new(@now, @now + 1)
-
-      self.handle_srp(tokens, span, options)
+      handle_srp(tokens, span, options)
     end
 
+    # Handle pointer/scalar/repeater
     def handle_p_s_r(tokens, options) #:nodoc:
       new_tokens = [tokens[1], tokens[2], tokens[0]]
-      self.handle_s_r_p(new_tokens, options)
+      handle_s_r_p(new_tokens, options)
     end
 
+    # Handle scalar/repeater/pointer/anchor
     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)
+      handle_srp(tokens, anchor_span, options)
     end
 
     # narrows
 
+    # Handle oridinal repeaters
     def handle_orr(tokens, outer_span, options) #:nodoc:
       repeater = tokens[1].get_tag(Repeater)
       repeater.start = outer_span.begin - 1
@@ -357,11 +239,13 @@ module Chronic
       span
     end
 
+    # Handle ordinal/repeater/separator/repeater
     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
 
+    # Handle ordinal/repeater/grabber/repeater
     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)
@@ -369,11 +253,22 @@ module Chronic
 
     # support methods
 
+    def day_or_time(day_start, time_tokens, options)
+      outer_span = Span.new(day_start, day_start + (24 * 60 * 60))
+
+      if !time_tokens.empty?
+        Chronic.now = outer_span.begin
+        get_anchor(dealias_and_disambiguate_times(time_tokens, options), options)
+      else
+        outer_span
+      end
+    end
+
     def get_anchor(tokens, options) #:nodoc:
       grabber = Grabber.new(:this)
       pointer = :future
 
-      repeaters = self.get_repeaters(tokens)
+      repeaters = get_repeaters(tokens)
       repeaters.size.times { tokens.pop }
 
       if tokens.first && tokens.first.get_tag(Grabber)
@@ -382,7 +277,7 @@ module Chronic
       end
 
       head = repeaters.shift
-      head.start = @now
+      head.start = Chronic.now
 
       case grabber.type
         when :last
@@ -404,8 +299,8 @@ module Chronic
 
     def get_repeaters(tokens) #:nodoc:
       repeaters = []
-		  tokens.each do |token|
-		    if t = token.get_tag(Repeater)
+      tokens.each do |token|
+        if t = token.get_tag(Repeater)
           repeaters << t
         end
       end
@@ -464,21 +359,6 @@ module Chronic
         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 = []
@@ -499,24 +379,38 @@ module Chronic
 
   end
 
-  class Handler #:nodoc:
-    attr_accessor :pattern, :handler_method
+  class Handler
+    # @return [Array] A list of patterns
+    attr_accessor :pattern
+
+    # @return [Symbol] The method which handles this list of patterns.
+    #   This method should exist inside the {Handlers} module
+    attr_accessor :handler_method
 
+    # @param [Array]  pattern A list of patterns to match tokens against
+    # @param [Symbol] handler_method The method to be invoked when patterns
+    #   are matched. This method should exist inside the {Handlers} module
     def initialize(pattern, handler_method)
       @pattern = pattern
       @handler_method = handler_method
     end
 
+    # @param [#to_s]  The snake_case name representing a Chronic constant
+    # @return [Class] The class represented by `name`
+    # @raise [NameError] Raises if this constant could not be found
     def constantize(name)
-      camel = name.to_s.gsub(/(^|_)(.)/) { $2.upcase }
-      ::Chronic.module_eval(camel, __FILE__, __LINE__)
+      Chronic.const_get name.to_s.gsub(/(^|_)(.)/) { $2.upcase }
     end
 
+    # @param [Array] tokens
+    # @param [Hash]  definitions
+    # @return [Boolean]
+    # @see Chronic.tokens_to_span
     def match(tokens, definitions)
       token_index = 0
       @pattern.each do |element|
         name = element.to_s
-        optional = name.reverse[0..0] == '?'
+        optional = name[-1, 1] == '?'
         name = name.chop if optional
         if element.instance_of? Symbol
           klass = constantize(name)
@@ -539,8 +433,10 @@ module Chronic
       return true
     end
 
+    # @param [Handler]  The handler to compare
+    # @return [Boolean] True if these handlers match
     def ==(other)
-      self.pattern == other.pattern
+      @pattern == other.pattern
     end
   end
 

data/lib/chronic/mini_date.rb

@@ -3,13 +3,17 @@ module Chronic
     attr_accessor :month, :day
 
     def initialize(month, day)
-      raise(InvalidArgumentException, "1..12 are valid months") unless (1..12).include?(month)
+      unless (1..12).include?(month)
+        raise(InvalidArgumentException, "1..12 are valid months")
+      end
+
       @month = month
       @day = day
     end
 
     def is_between?(md_start, md_end)
-      return false if (@month==md_start.month && @month==md_end.month && (@day < md_start.day || @day > md_end.day))
+      return false if (@month == md_start.month && @month == md_end.month &&
+                      (@day < md_start.day || @day > md_end.day))
       return true if (@month == md_start.month and @day >= md_start.day) ||
                      (@month == md_end.month and @day <= md_end.day)
       i = (md_start.month % 12) + 1

data/lib/chronic/ordinal.rb

@@ -1,16 +1,27 @@
 module Chronic
-  class Ordinal < Tag #:nodoc:
+  class Ordinal < Tag
+
+    # Scan an Array of {Token}s and apply any necessary Ordinal tags to
+    # each token
+    #
+    # @param [Array<Token>] tokens Array of tokens to scan
+    # @param [Hash] options Options specified in {Chronic.parse}
+    # @return [Array] list of tokens
     def self.scan(tokens, options)
-      tokens.each_index do |i|
-        if t = scan_for_ordinals(tokens[i]) then tokens[i].tag(t) end
-        if t = scan_for_days(tokens[i]) then tokens[i].tag(t) end
+      tokens.each do |token|
+        if t = scan_for_ordinals(token) then token.tag(t) end
+        if t = scan_for_days(token) then token.tag(t) end
       end
     end
 
+    # @param [Token] token
+    # @return [Ordinal, nil]
     def self.scan_for_ordinals(token)
       Ordinal.new($1.to_i) if token.word =~ /^(\d*)(st|nd|rd|th)$/
     end
 
+    # @param [Token] token
+    # @return [OrdinalDay, nil]
     def self.scan_for_days(token)
       if token.word =~ /^(\d*)(st|nd|rd|th)$/
         unless $1.to_i > 31 || $1.to_i < 1

data/lib/chronic/pointer.rb

@@ -1,11 +1,20 @@
 module Chronic
-  class Pointer < Tag #:nodoc:
+  class Pointer < Tag
+
+    # Scan an Array of {Token}s and apply any necessary Pointer tags to
+    # each token
+    #
+    # @param [Array<Token>] tokens Array of tokens to scan
+    # @param [Hash] options Options specified in {Chronic.parse}
+    # @return [Array] list of tokens
     def self.scan(tokens, options)
-      tokens.each_index do |i|
-        if t = scan_for_all(tokens[i]) then tokens[i].tag(t) end
+      tokens.each do |token|
+        if t = scan_for_all(token) then token.tag(t) end
       end
     end
 
+    # @param [Token] token
+    # @return [Pointer, nil]
     def self.scan_for_all(token)
       scan_for token, self,
       {

data/lib/chronic/repeater.rb

@@ -1,16 +1,25 @@
 module Chronic
-  class Repeater < Tag #:nodoc:
+  class Repeater < Tag
+
+    # Scan an Array of {Token}s and apply any necessary Repeater tags to
+    # each token
+    #
+    # @param [Array<Token>] tokens Array of tokens to scan
+    # @param [Hash] options Options specified in {Chronic.parse}
+    # @return [Array] list of tokens
     def self.scan(tokens, options)
-      tokens.each_index do |i|
-        if t = scan_for_season_names(tokens[i]) then tokens[i].tag(t); next end
-        if t = scan_for_month_names(tokens[i]) then tokens[i].tag(t); next end
-        if t = scan_for_day_names(tokens[i]) then tokens[i].tag(t); next end
-        if t = scan_for_day_portions(tokens[i]) then tokens[i].tag(t); next end
-        if t = scan_for_times(tokens[i]) then tokens[i].tag(t); next end
-        if t = scan_for_units(tokens[i]) then tokens[i].tag(t); next end
+      tokens.each do |token|
+        if t = scan_for_season_names(token) then token.tag(t); next end
+        if t = scan_for_month_names(token) then token.tag(t); next end
+        if t = scan_for_day_names(token) then token.tag(t); next end
+        if t = scan_for_day_portions(token) then token.tag(t); next end
+        if t = scan_for_times(token) then token.tag(t); next end
+        if t = scan_for_units(token) then token.tag(t); next end
       end
     end
 
+    # @param [Token] token
+    # @return [RepeaterSeasonName, nil]
     def self.scan_for_season_names(token)
       scan_for token, RepeaterSeasonName,
       {
@@ -21,6 +30,8 @@ module Chronic
       }
     end
 
+    # @param [Token] token
+    # @return [RepeaterMonthName, nil]
     def self.scan_for_month_names(token)
       scan_for token, RepeaterMonthName,
       {
@@ -39,6 +50,8 @@ module Chronic
       }
     end
 
+    # @param [Token] token
+    # @return [RepeaterDayName, nil]
     def self.scan_for_day_names(token)
       scan_for token, RepeaterDayName,
       {
@@ -55,6 +68,8 @@ module Chronic
       }
     end
 
+    # @param [Token] token
+    # @return [RepeaterDayPortion, nil]
     def self.scan_for_day_portions(token)
       scan_for token, RepeaterDayPortion,
       {
@@ -67,10 +82,14 @@ module Chronic
       }
     end
 
+    # @param [Token] token
+    # @return [RepeaterTime, nil]
     def self.scan_for_times(token)
       scan_for token, RepeaterTime, /^\d{1,2}(:?\d{2})?([\.:]?\d{2})?$/
     end
 
+    # @param [Token] token
+    # @return [Repeater] A new instance of a subclass of Repeater
     def self.scan_for_units(token)
       {
         /^years?$/ => :year,
@@ -100,7 +119,7 @@ module Chronic
 
     # returns the width (in seconds or months) of this repeatable.
     def width
-      raise("Repeatable#width must be overridden in subclasses")
+      raise("Repeater#width must be overridden in subclasses")
     end
 
     # returns the next occurance of this repeatable.

data/lib/chronic/repeaters/repeater_day.rb

@@ -4,7 +4,6 @@ module Chronic
 
     def initialize(type)
       super
-      @current_day_start = nil
     end
 
     def next(pointer)

data/lib/chronic/repeaters/repeater_day_name.rb

@@ -4,7 +4,6 @@ module Chronic
 
     def initialize(type)
       super
-      @current_day_start = nil
     end
 
     def next(pointer)

data/lib/chronic/repeaters/repeater_day_portion.rb

@@ -11,7 +11,6 @@ module Chronic
 
     def initialize(type)
       super
-      @current_span = nil
 
       if type.kind_of? Integer
         @range = (@type * 60 * 60)..((@type + 12) * 60 * 60)

data/lib/chronic/repeaters/repeater_fortnight.rb

@@ -4,7 +4,6 @@ module Chronic
 
     def initialize(type)
       super
-      @current_fortnight_start = nil
     end
 
     def next(pointer)

data/lib/chronic/repeaters/repeater_hour.rb

@@ -4,7 +4,6 @@ module Chronic
 
     def initialize(type)
       super
-      @current_hour_start = nil
     end
 
     def next(pointer)