chronic 0.3.0 → 0.4.0

data/lib/chronic/grabber.rb

@@ -1,26 +1,22 @@
-#module Chronic
-
-  class Chronic::Grabber < Chronic::Tag #:nodoc:
-    def self.scan(tokens)
+module Chronic
+  class Grabber < Tag #:nodoc:
+    def self.scan(tokens, options)
       tokens.each_index do |i|
-        if t = self.scan_for_all(tokens[i]) then tokens[i].tag(t); next end
+        if t = 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
+      scan_for token, self,
+      {
+        /last/ => :last,
+        /this/ => :this,
+        /next/ => :next
+      }
     end
 
     def to_s
       'grabber-' << @type.to_s
     end
   end
-
-#end
+end

data/lib/chronic/handlers.rb

@@ -3,8 +3,7 @@ module Chronic
   class << self
 
     def definitions(options={}) #:nodoc:
-      options[:endian_precedence] = [:middle, :little] if options[:endian_precedence].nil?
-
+      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
 
@@ -19,36 +18,48 @@ module Chronic
         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)]
+      @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])
@@ -130,10 +141,9 @@ module Chronic
 
       if !time_tokens.empty?
         @now = outer_span.begin
-        time = get_anchor(dealias_and_disambiguate_times(time_tokens, options), options)
-        return time
+        get_anchor(dealias_and_disambiguate_times(time_tokens, options), options)
       else
-        return outer_span
+        outer_span
       end
     end
 
@@ -211,6 +221,21 @@ module Chronic
       end
     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_sd_rmn_sy(tokens, options) #:nodoc:
       new_tokens = [tokens[1], tokens[0], tokens[2]]
       time_tokens = tokens.last(tokens.size - 3)
@@ -363,7 +388,7 @@ module Chronic
         when :last
           outer_span = head.next(:past)
         when :this
-          if repeaters.size > 0
+          if options[:context] != :past and repeaters.size > 0
             outer_span = head.this(:none)
           else
             outer_span = head.this(options[:context])
@@ -398,10 +423,8 @@ module Chronic
       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
+      if span.cover?(h.begin) || span.cover?(h.end)
+        find_within(rest, h, pointer)
       end
     end
 

data/lib/chronic/mini_date.rb

@@ -0,0 +1,27 @@
+module Chronic
+  class MiniDate
+    attr_accessor :month, :day
+
+    def initialize(month, day)
+      @month = month
+      @day = day
+    end
+
+    def is_between?(md_start, md_end)
+      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 + 1
+      until i == md_end.month
+        return true if @month == i
+        i = (i+1) % 12
+      end
+
+      return false
+    end
+
+    def equals?(other)
+      @month == other.month and day == other.day
+    end
+  end
+end

data/lib/chronic/numerizer.rb

@@ -0,0 +1,120 @@
+require 'strscan'
+
+module Chronic
+  class Numerizer
+
+    DIRECT_NUMS = [
+      ['eleven', '11'],
+      ['twelve', '12'],
+      ['thirteen', '13'],
+      ['fourteen', '14'],
+      ['fifteen', '15'],
+      ['sixteen', '16'],
+      ['seventeen', '17'],
+      ['eighteen', '18'],
+      ['nineteen', '19'],
+      ['ninteen', '19'], # Common mis-spelling
+      ['zero', '0'],
+      ['one', '1'],
+      ['two', '2'],
+      ['three', '3'],
+      ['four(\W|$)', '4\1'],  # The weird regex is so that it matches four but not fourty
+      ['five', '5'],
+      ['six(\W|$)', '6\1'],
+      ['seven(\W|$)', '7\1'],
+      ['eight(\W|$)', '8\1'],
+      ['nine(\W|$)', '9\1'],
+      ['ten', '10'],
+      ['\ba[\b^$]', '1'] # doesn't make sense for an 'a' at the end to be a 1
+    ]
+
+    ORDINALS = [
+      ['first', '1'],
+      ['third', '3'],
+      ['fourth', '4'],
+      ['fifth', '5'],
+      ['sixth', '6'],
+      ['seventh', '7'],
+      ['eighth', '8'],
+      ['ninth', '9'],
+      ['tenth', '10']
+    ]
+
+    TEN_PREFIXES = [
+      ['twenty', 20],
+      ['thirty', 30],
+      ['forty', 40],
+      ['fourty', 40], # Common mis-spelling
+      ['fifty', 50],
+      ['sixty', 60],
+      ['seventy', 70],
+      ['eighty', 80],
+      ['ninety', 90]
+    ]
+
+    BIG_PREFIXES = [
+      ['hundred', 100],
+      ['thousand', 1000],
+      ['million', 1_000_000],
+      ['billion', 1_000_000_000],
+      ['trillion', 1_000_000_000_000],
+    ]
+
+    def self.numerize(string)
+      string = string.dup
+
+      # preprocess
+      string.gsub!(/ +|([^\d])-([^\d])/, '\1 \2') # will mutilate hyphenated-words but shouldn't matter for date extraction
+      string.gsub!(/a half/, 'haAlf') # take the 'a' out so it doesn't turn into a 1, save the half for the end
+
+      # easy/direct replacements
+
+      DIRECT_NUMS.each do |dn|
+        string.gsub!(/#{dn[0]}/i, '<num>' + dn[1])
+      end
+
+      ORDINALS.each do |on|
+        string.gsub!(/#{on[0]}/i, '<num>' + on[1] + on[0][-2, 2])
+      end
+
+      # ten, twenty, etc.
+
+      TEN_PREFIXES.each do |tp|
+        string.gsub!(/(?:#{tp[0]}) *<num>(\d(?=[^\d]|$))*/i) { '<num>' + (tp[1] + $1.to_i).to_s }
+      end
+
+      TEN_PREFIXES.each do |tp|
+        string.gsub!(/#{tp[0]}/i) { '<num>' + tp[1].to_s }
+      end
+
+      # hundreds, thousands, millions, etc.
+
+      BIG_PREFIXES.each do |bp|
+        string.gsub!(/(?:<num>)?(\d*) *#{bp[0]}/i) { '<num>' + (bp[1] * $1.to_i).to_s}
+        andition(string)
+      end
+
+      # fractional addition
+      # I'm not combining this with the previous block as using float addition complicates the strings
+      # (with extraneous .0's and such )
+      string.gsub!(/(\d+)(?: | and |-)*haAlf/i) { ($1.to_f + 0.5).to_s }
+
+      string.gsub(/<num>/, '')
+    end
+
+    class << self
+      private
+
+      def andition(string)
+        sc = StringScanner.new(string)
+        while(sc.scan_until(/<num>(\d+)( | and )<num>(\d+)(?=[^\w]|$)/i))
+          if sc[2] =~ /and/ || sc[1].size > sc[3].size
+            string[(sc.pos - sc.matched_size)..(sc.pos-1)] = '<num>' + (sc[1].to_i + sc[3].to_i).to_s
+            sc.reset
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/chronic/ordinal.rb

@@ -1,29 +1,24 @@
 module Chronic
 
   class Ordinal < Tag #:nodoc:
-    def self.scan(tokens)
+    def self.scan(tokens, options)
       # for each token
       tokens.each_index do |i|
-        if t = self.scan_for_ordinals(tokens[i]) then tokens[i].tag(t) end
-        if t = self.scan_for_days(tokens[i]) then tokens[i].tag(t) end
+        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
       end
-      tokens
     end
 
     def self.scan_for_ordinals(token)
-      if token.word =~ /^(\d*)(st|nd|rd|th)$/
-        return Ordinal.new($1.to_i)
-      end
-      return nil
+      Ordinal.new($1.to_i) if token.word =~ /^(\d*)(st|nd|rd|th)$/
     end
 
     def self.scan_for_days(token)
       if token.word =~ /^(\d*)(st|nd|rd|th)$/
         unless $1.to_i > 31 || $1.to_i < 1
-          return OrdinalDay.new(token.word.to_i)
+          OrdinalDay.new(token.word.to_i)
         end
       end
-      return nil
     end
 
     def to_s

data/lib/chronic/pointer.rb

@@ -1,22 +1,20 @@
 module Chronic
 
   class Pointer < Tag #:nodoc:
-    def self.scan(tokens)
+    def self.scan(tokens, options)
       # for each token
       tokens.each_index do |i|
-        if t = self.scan_for_all(tokens[i]) then tokens[i].tag(t) end
+        if t = scan_for_all(tokens[i]) then tokens[i].tag(t) end
       end
-      tokens
     end
 
     def self.scan_for_all(token)
-      scanner = {/\bpast\b/ => :past,
-                 /\bfuture\b/ => :future,
-                 /\bin\b/ => :future}
-      scanner.keys.each do |scanner_item|
-        return self.new(scanner[scanner_item]) if scanner_item =~ token.word
-      end
-      return nil
+      scan_for token, self,
+      {
+        /\bpast\b/ => :past,
+        /\bfuture\b/ => :future,
+        /\bin\b/ => :future
+      }
     end
 
     def to_s

data/lib/chronic/repeater.rb

@@ -1,129 +1,126 @@
-class Chronic::Repeater < Chronic::Tag #:nodoc:
-  def self.scan(tokens, options)
-    # for each token
-    tokens.each_index do |i|
-      if t = self.scan_for_season_names(tokens[i]) then tokens[i].tag(t); next end
-      if t = self.scan_for_month_names(tokens[i]) then tokens[i].tag(t); next end
-      if t = self.scan_for_day_names(tokens[i]) then tokens[i].tag(t); next end
-      if t = self.scan_for_day_portions(tokens[i]) then tokens[i].tag(t); next end
-      if t = self.scan_for_times(tokens[i], options) then tokens[i].tag(t); next end
-      if t = self.scan_for_units(tokens[i]) then tokens[i].tag(t); next end
+module Chronic
+  class Repeater < Tag #:nodoc:
+    def self.scan(tokens, options)
+      # for each token
+      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
+      end
     end
-    tokens
-  end
 
-  def self.scan_for_season_names(token)
-    scanner = {/^springs?$/ => :spring,
-               /^summers?$/ => :summer,
-               /^(autumn)|(fall)s?$/ => :autumn,
-               /^winters?$/ => :winter}
-    scanner.keys.each do |scanner_item|
-      return Chronic::RepeaterSeasonName.new(scanner[scanner_item]) if scanner_item =~ token.word
+    def self.scan_for_season_names(token)
+      scan_for token, RepeaterSeasonName,
+      {
+        /^springs?$/ => :spring,
+        /^summers?$/ => :summer,
+        /^(autumn)|(fall)s?$/ => :autumn,
+        /^winters?$/ => :winter
+      }
     end
 
-    return nil
-  end
-
-  def self.scan_for_month_names(token)
-    scanner = {/^jan\.?(uary)?$/ => :january,
-               /^feb\.?(ruary)?$/ => :february,
-               /^mar\.?(ch)?$/ => :march,
-               /^apr\.?(il)?$/ => :april,
-               /^may$/ => :may,
-               /^jun\.?e?$/ => :june,
-               /^jul\.?y?$/ => :july,
-               /^aug\.?(ust)?$/ => :august,
-               /^sep\.?(t\.?|tember)?$/ => :september,
-               /^oct\.?(ober)?$/ => :october,
-               /^nov\.?(ember)?$/ => :november,
-               /^dec\.?(ember)?$/ => :december}
-    scanner.keys.each do |scanner_item|
-      return Chronic::RepeaterMonthName.new(scanner[scanner_item]) if scanner_item =~ token.word
+    def self.scan_for_month_names(token)
+      scan_for token, RepeaterMonthName,
+      {
+        /^jan\.?(uary)?$/ => :january,
+        /^feb\.?(ruary)?$/ => :february,
+        /^mar\.?(ch)?$/ => :march,
+        /^apr\.?(il)?$/ => :april,
+        /^may$/ => :may,
+        /^jun\.?e?$/ => :june,
+        /^jul\.?y?$/ => :july,
+        /^aug\.?(ust)?$/ => :august,
+        /^sep\.?(t\.?|tember)?$/ => :september,
+        /^oct\.?(ober)?$/ => :october,
+        /^nov\.?(ember)?$/ => :november,
+        /^dec\.?(ember)?$/ => :december
+      }
     end
-    return nil
-  end
 
-  def self.scan_for_day_names(token)
-    scanner = {/^m[ou]n(day)?$/ => :monday,
-               /^t(ue|eu|oo|u|)s(day)?$/ => :tuesday,
-               /^tue$/ => :tuesday,
-               /^we(dnes|nds|nns)day$/ => :wednesday,
-               /^wed$/ => :wednesday,
-               /^th(urs|ers)day$/ => :thursday,
-               /^thu$/ => :thursday,
-               /^fr[iy](day)?$/ => :friday,
-               /^sat(t?[ue]rday)?$/ => :saturday,
-               /^su[nm](day)?$/ => :sunday}
-    scanner.keys.each do |scanner_item|
-      return Chronic::RepeaterDayName.new(scanner[scanner_item]) if scanner_item =~ token.word
+    def self.scan_for_day_names(token)
+      scan_for token, RepeaterDayName,
+      {
+        /^m[ou]n(day)?$/ => :monday,
+        /^t(ue|eu|oo|u|)s(day)?$/ => :tuesday,
+        /^tue$/ => :tuesday,
+        /^we(dnes|nds|nns)day$/ => :wednesday,
+        /^wed$/ => :wednesday,
+        /^th(urs|ers)day$/ => :thursday,
+        /^thu(rs)?$/ => :thursday,
+        /^fr[iy](day)?$/ => :friday,
+        /^sat(t?[ue]rday)?$/ => :saturday,
+        /^su[nm](day)?$/ => :sunday
+      }
     end
-    return nil
-  end
 
-  def self.scan_for_day_portions(token)
-    scanner = {/^ams?$/ => :am,
-               /^pms?$/ => :pm,
-               /^mornings?$/ => :morning,
-               /^afternoons?$/ => :afternoon,
-               /^evenings?$/ => :evening,
-               /^(night|nite)s?$/ => :night}
-    scanner.keys.each do |scanner_item|
-      return Chronic::RepeaterDayPortion.new(scanner[scanner_item]) if scanner_item =~ token.word
+    def self.scan_for_day_portions(token)
+      scan_for token, RepeaterDayPortion,
+      {
+        /^ams?$/ => :am,
+        /^pms?$/ => :pm,
+        /^mornings?$/ => :morning,
+        /^afternoons?$/ => :afternoon,
+        /^evenings?$/ => :evening,
+        /^(night|nite)s?$/ => :night
+      }
     end
-    return nil
-  end
 
-  def self.scan_for_times(token, options)
-    if token.word =~ /^\d{1,2}(:?\d{2})?([\.:]?\d{2})?$/
-      return Chronic::RepeaterTime.new(token.word, options)
+    def self.scan_for_times(token)
+      if token.word =~ /^\d{1,2}(:?\d{2})?([\.:]?\d{2})?$/
+        return Chronic::RepeaterTime.new(token.word)
+      end
+      return nil
     end
-    return nil
-  end
 
-  def self.scan_for_units(token)
-    scanner = {/^years?$/ => :year,
-               /^seasons?$/ => :season,
-               /^months?$/ => :month,
-               /^fortnights?$/ => :fortnight,
-               /^weeks?$/ => :week,
-               /^weekends?$/ => :weekend,
-               /^(week|business)days?$/ => :weekday,
-               /^days?$/ => :day,
-               /^hours?$/ => :hour,
-               /^minutes?$/ => :minute,
-               /^seconds?$/ => :second}
-    scanner.keys.each do |scanner_item|
-      if scanner_item =~ token.word
-        klass_name = 'Chronic::Repeater' + scanner[scanner_item].to_s.capitalize
-        klass = eval(klass_name)
-        return klass.new(scanner[scanner_item])
+    def self.scan_for_units(token)
+      {
+        /^years?$/ => :year,
+        /^seasons?$/ => :season,
+        /^months?$/ => :month,
+        /^fortnights?$/ => :fortnight,
+        /^weeks?$/ => :week,
+        /^weekends?$/ => :weekend,
+        /^(week|business)days?$/ => :weekday,
+        /^days?$/ => :day,
+        /^hours?$/ => :hour,
+        /^minutes?$/ => :minute,
+        /^seconds?$/ => :second
+      }.each do |item, symbol|
+        if item =~ token.word
+          klass_name = 'Repeater' + symbol.to_s.capitalize
+          klass = Chronic.const_get(klass_name)
+          return klass.new(symbol)
+        end
       end
+      return nil
     end
-    return nil
-  end
 
-  def <=>(other)
-    width <=> other.width
-  end
+    def <=>(other)
+      width <=> other.width
+    end
 
-  # returns the width (in seconds or months) of this repeatable.
-  def width
-    raise("Repeatable#width must be overridden in subclasses")
-  end
+    # returns the width (in seconds or months) of this repeatable.
+    def width
+      raise("Repeatable#width must be overridden in subclasses")
+    end
 
-  # returns the next occurance of this repeatable.
-  def next(pointer)
-    !@now.nil? || raise("Start point must be set before calling #next")
-    [:future, :none, :past].include?(pointer) || raise("First argument 'pointer' must be one of :past or :future")
-    #raise("Repeatable#next must be overridden in subclasses")
-  end
+    # returns the next occurance of this repeatable.
+    def next(pointer)
+      !@now.nil? || raise("Start point must be set before calling #next")
+      [:future, :none, :past].include?(pointer) || raise("First argument 'pointer' must be one of :past or :future")
+      #raise("Repeatable#next must be overridden in subclasses")
+    end
 
-  def this(pointer)
-    !@now.nil? || raise("Start point must be set before calling #this")
-    [:future, :past, :none].include?(pointer) || raise("First argument 'pointer' must be one of :past, :future, :none")
-  end
+    def this(pointer)
+      !@now.nil? || raise("Start point must be set before calling #this")
+      [:future, :past, :none].include?(pointer) || raise("First argument 'pointer' must be one of :past, :future, :none")
+    end
 
-  def to_s
-    'repeater'
+    def to_s
+      'repeater'
+    end
   end
-end
+end