chronic-mmlac 0.6.4.2 → 0.10.2.1

data/lib/chronic/numerizer.rb

@@ -37,7 +37,16 @@ module Chronic
       ['seventh', '7'],
       ['eighth', '8'],
       ['ninth', '9'],
-      ['tenth', '10']
+      ['tenth', '10'],
+      ['twelfth', '12'],
+      ['twentieth', '20'],
+      ['thirtieth', '30'],
+      ['fourtieth', '40'],
+      ['fiftieth', '50'],
+      ['sixtieth', '60'],
+      ['seventieth', '70'],
+      ['eightieth', '80'],
+      ['ninetieth', '90']
     ]
 
     TEN_PREFIXES = [
@@ -90,7 +99,7 @@ module Chronic
       # hundreds, thousands, millions, etc.
 
       BIG_PREFIXES.each do |bp|
-        string.gsub!(/(?:<num>)?(\d*) *#{bp[0]}/i) { '<num>' + (bp[1] * $1.to_i).to_s}
+        string.gsub!(/(?:<num>)?(\d*) *#{bp[0]}/i) { $1.empty? ? bp[1] : '<num>' + (bp[1] * $1.to_i).to_s}
         andition(string)
       end
 

data/lib/chronic/ordinal.rb

@@ -1,31 +1,24 @@
 module Chronic
   class Ordinal < Tag
 
-    # Scan an Array of {Token}s and apply any necessary Ordinal tags to
-    # each token
+    # Scan an Array of Token objects 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
+    # tokens - An Array of tokens to scan.
+    # options - The Hash of options specified in Chronic::parse.
+    #
+    # Returns an Array of tokens.
     def self.scan(tokens, options)
-      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
-          OrdinalDay.new(token.word.to_i)
+      tokens.each_index do |i|
+        if tokens[i].word =~ /^(\d+)(st|nd|rd|th|\.)$/
+            ordinal = $1.to_i
+            tokens[i].tag(Ordinal.new(ordinal))
+            tokens[i].tag(OrdinalDay.new(ordinal)) if Chronic::Date::could_be_day?(ordinal)
+            tokens[i].tag(OrdinalMonth.new(ordinal)) if Chronic::Date::could_be_month?(ordinal)
+            if Chronic::Date::could_be_year?(ordinal)
+                year = Chronic::Date::make_year(ordinal, options[:ambiguous_year_future_bias])
+                tokens[i].tag(OrdinalYear.new(year.to_i))
+            end
         end
       end
     end
@@ -41,4 +34,16 @@ module Chronic
     end
   end
 
+  class OrdinalMonth < Ordinal #:nodoc:
+    def to_s
+      super << '-month-' << @type.to_s
+    end
+  end
+
+  class OrdinalYear < Ordinal #:nodoc:
+    def to_s
+      super << '-year-' << @type.to_s
+    end
+  end
+
 end

data/lib/chronic/parser.rb

@@ -0,0 +1,268 @@
+require 'chronic/handlers'
+
+module Chronic
+  class Parser
+    include Handlers
+
+    # Hash of default configuration options.
+    DEFAULT_OPTIONS = {
+      :context => :future,
+      :now => nil,
+      :hours24 => nil,
+      :guess => true,
+      :ambiguous_time_range => 6,
+      :endian_precedence    => [:middle, :little],
+      :ambiguous_year_future_bias => 50
+    }
+
+    attr_accessor :now
+    attr_reader :options
+
+    # options - An optional Hash of configuration options:
+    #        :context - If your string represents a birthday, you can set
+    #                   this value to :past and if an ambiguous string is
+    #                   given, it will assume it is in the past.
+    #        :now - Time, all computations will be based off of time
+    #               instead of Time.now.
+    #        :hours24 - Time will be parsed as it would be 24 hour clock.
+    #        :guess - 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 this to false
+    #                 and a Chronic::Span will be returned. Setting :guess to :end
+    #                 will return last time from Span, to :middle for middle (same as just true)
+    #                 and :begin for first time from span.
+    #        :ambiguous_time_range - 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 `7`, 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 `:none`
+    #                  is given, no assumption will be made, and the first
+    #                  matching instance of that time will be used.
+    #        :endian_precedence - By default, Chronic will parse "03/04/2011"
+    #                 as the fourth day of the third month. Alternatively you
+    #                 can tell Chronic to parse this as the third day of the
+    #                 fourth month by setting this to [:little, :middle].
+    #        :ambiguous_year_future_bias - When parsing two digit years
+    #                 (ie 79) unlike Rubys Time class, Chronic will attempt
+    #                 to assume the full year using this figure. Chronic will
+    #                 look x amount of years into the future and past. If the
+    #                 two digit year is `now + x years` it's assumed to be the
+    #                 future, `now - x years` is assumed to be the past.
+    def initialize(options = {})
+      @options = DEFAULT_OPTIONS.merge(options)
+      @now = options.delete(:now) || Chronic.time_class.now
+    end
+
+    # Parse "text" with the given options
+    # Returns either a Time or Chronic::Span, depending on the value of options[:guess]
+    def parse(text)
+      tokens = tokenize(text, options)
+      span = tokens_to_span(tokens, options.merge(:text => text))
+
+      puts "+#{'-' * 51}\n| #{tokens}\n+#{'-' * 51}" if Chronic.debug
+
+      guess(span, options[:guess]) if span
+    end
+
+    # Clean up the specified text ready for parsing.
+    #
+    # Clean up the string 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)
+    #
+    # text - The String text to normalize.
+    #
+    # Examples:
+    #
+    #   Chronic.pre_normalize('first day in May')
+    #     #=> "1st day in may"
+    #
+    #   Chronic.pre_normalize('tomorrow after noon')
+    #     #=> "next day future 12:00"
+    #
+    #   Chronic.pre_normalize('one hundred and thirty six days from now')
+    #     #=> "136 days future this second"
+    #
+    # Returns a new String ready for Chronic to parse.
+    def pre_normalize(text)
+      text = text.to_s.downcase
+      text.gsub!(/\b(\d{2})\.(\d{2})\.(\d{4})\b/, '\3 / \2 / \1')
+      text.gsub!(/\b([ap])\.m\.?/, '\1m')
+      text.gsub!(/(\s+|:\d{2}|:\d{2}\.\d{3})\-(\d{2}:?\d{2})\b/, '\1tzminus\2')
+      text.gsub!(/\./, ':')
+      text.gsub!(/([ap]):m:?/, '\1m')
+      text.gsub!(/['"]/, '')
+      text.gsub!(/,/, ' ')
+      text.gsub!(/^second /, '2nd ')
+      text.gsub!(/\bsecond (of|day|month|hour|minute|second)\b/, '2nd \1')
+      text = Numerizer.numerize(text)
+      text.gsub!(/([\/\-\,\@])/) { ' ' + $1 + ' ' }
+      text.gsub!(/(?:^|\s)0(\d+:\d+\s*pm?\b)/, ' \1')
+      text.gsub!(/\btoday\b/, 'this day')
+      text.gsub!(/\btomm?orr?ow\b/, 'next day')
+      text.gsub!(/\byesterday\b/, 'last day')
+      text.gsub!(/\bnoon\b/, '12:00pm')
+      text.gsub!(/\bmidnight\b/, '24:00')
+      text.gsub!(/\bnow\b/, 'this second')
+      text.gsub!('quarter', '15')
+      text.gsub!('half', '30')
+      text.gsub!(/(\d{1,2}) (to|till|prior to|before)\b/, '\1 minutes past')
+      text.gsub!(/(\d{1,2}) (after|past)\b/, '\1 minutes future')
+      text.gsub!(/\b(?:ago|before(?: now)?)\b/, 'past')
+      text.gsub!(/\bthis (?:last|past)\b/, 'last')
+      text.gsub!(/\b(?:in|during) the (morning)\b/, '\1')
+      text.gsub!(/\b(?:in the|during the|at) (afternoon|evening|night)\b/, '\1')
+      text.gsub!(/\btonight\b/, 'this night')
+      text.gsub!(/\b\d+:?\d*[ap]\b/,'\0m')
+      text.gsub!(/\b(\d{2})(\d{2})(am|pm)\b/, '\1:\2\3')
+      text.gsub!(/(\d)([ap]m|oclock)\b/, '\1 \2')
+      text.gsub!(/\b(hence|after|from)\b/, 'future')
+      text.gsub!(/^\s?an? /i, '1 ')
+      text.gsub!(/\b(\d{4}):(\d{2}):(\d{2})\b/, '\1 / \2 / \3') # DTOriginal
+      text.gsub!(/\b0(\d+):(\d{2}):(\d{2}) ([ap]m)\b/, '\1:\2:\3 \4')
+      text
+    end
+
+    # Guess a specific time within the given span.
+    #
+    # span - The Chronic::Span object to calcuate a guess from.
+    #
+    # Returns a new Time object.
+    def guess(span, mode = :middle)
+      return span if not mode
+      return span.begin + span.width / 2 if span.width > 1 and (mode == true or mode == :middle)
+      return span.end if mode == :end
+      span.begin
+    end
+
+    # List of Handler definitions. See Chronic.parse for a list of options this
+    # method accepts.
+    #
+    # options - An optional Hash of configuration options.
+    #
+    # Returns a Hash of Handler definitions.
+    def definitions(options = {})
+      options[:endian_precedence] ||= [:middle, :little]
+
+      @@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?, :separator_dash?], :time_zone, :scalar_year], :handle_generic),
+          Handler.new([:repeater_day_name, :repeater_month_name, :scalar_day], :handle_rdn_rmn_sd),
+          Handler.new([:repeater_day_name, :repeater_month_name, :scalar_day, :scalar_year], :handle_rdn_rmn_sd_sy),
+          Handler.new([:repeater_day_name, :repeater_month_name, :ordinal_day], :handle_rdn_rmn_od),
+          Handler.new([:repeater_day_name, :repeater_month_name, :ordinal_day, :scalar_year], :handle_rdn_rmn_od_sy),
+          Handler.new([:repeater_day_name, :repeater_month_name, :scalar_day, :separator_at?, 'time?'], :handle_rdn_rmn_sd),
+          Handler.new([:repeater_day_name, :repeater_month_name, :ordinal_day, :separator_at?, 'time?'], :handle_rdn_rmn_od),
+          Handler.new([:repeater_day_name, :ordinal_day, :separator_at?, 'time?'], :handle_rdn_od),
+          Handler.new([:scalar_year, [:separator_slash, :separator_dash], :scalar_month, [:separator_slash, :separator_dash], :scalar_day, :repeater_time, :time_zone], :handle_generic),
+          Handler.new([:ordinal_day], :handle_generic),
+          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, [:separator_slash?, :separator_dash?], :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([:ordinal_day, :repeater_month_name, :scalar_year, :separator_at?, 'time?'], :handle_od_rmn_sy),
+          Handler.new([:ordinal_day, :repeater_month_name, :separator_at?, 'time?'], :handle_od_rmn),
+          Handler.new([:ordinal_day, :grabber?, :repeater_month, :separator_at?, 'time?'], :handle_od_rm),
+          Handler.new([:scalar_year, :repeater_month_name, :ordinal_day], :handle_sy_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_day, [:separator_slash?, :separator_dash?], :repeater_month_name, :separator_at?, 'time?'], :handle_sd_rmn),
+          Handler.new([:scalar_year, [:separator_slash, :separator_dash], :scalar_month, [:separator_slash, :separator_dash], :scalar_day, :separator_at?, 'time?'], :handle_sy_sm_sd),
+          Handler.new([:scalar_year, [:separator_slash, :separator_dash], :scalar_month], :handle_sy_sm),
+          Handler.new([:scalar_month, [:separator_slash, :separator_dash], :scalar_year], :handle_sm_sy),
+          Handler.new([:scalar_day, [:separator_slash, :separator_dash], :repeater_month_name, [:separator_slash, :separator_dash], :scalar_year, :repeater_time?], :handle_sm_rmn_sy),
+          Handler.new([:scalar_year, [:separator_slash, :separator_dash], :scalar_month, [:separator_slash, :separator_dash], :scalar?, :time_zone], :handle_generic),
+        ],
+
+        :anchor => [
+          Handler.new([:separator_on?, :grabber?, :repeater, :separator_at?, :repeater?, :repeater?], :handle_r),
+          Handler.new([:grabber?, :repeater, :repeater, :separator?, :repeater?, :repeater?], :handle_r),
+          Handler.new([:repeater, :grabber, :repeater], :handle_r_g_r)
+        ],
+
+        :arrow => [
+          Handler.new([:scalar, :repeater, :pointer], :handle_s_r_p),
+          Handler.new([:scalar, :repeater, :separator_and?, :scalar, :repeater, :pointer, :separator_at?, 'anchor'], :handle_s_r_a_s_r_p_a),
+          Handler.new([:pointer, :scalar, :repeater], :handle_p_s_r),
+          Handler.new([:scalar, :repeater, :pointer, :separator_at?, 'anchor'], :handle_s_r_p_a)
+        ],
+
+        :narrow => [
+          Handler.new([:ordinal, :repeater, :separator_in, :repeater], :handle_o_r_s_r),
+          Handler.new([:ordinal, :repeater, :grabber, :repeater], :handle_o_r_g_r)
+        ]
+      }
+
+      endians = [
+        Handler.new([:scalar_month, [:separator_slash, :separator_dash], :scalar_day, [:separator_slash, :separator_dash], :scalar_year, :separator_at?, 'time?'], :handle_sm_sd_sy),
+        Handler.new([:scalar_month, [:separator_slash, :separator_dash], :scalar_day, :separator_at?, 'time?'], :handle_sm_sd),
+        Handler.new([:scalar_day, [:separator_slash, :separator_dash], :scalar_month, :separator_at?, 'time?'], :handle_sd_sm),
+        Handler.new([:scalar_day, [:separator_slash, :separator_dash], :scalar_month, [:separator_slash, :separator_dash], :scalar_year, :separator_at?, 'time?'], :handle_sd_sm_sy)
+      ]
+
+      case endian = Array(options[:endian_precedence]).first
+      when :little
+        @@definitions.merge(:endian => endians.reverse)
+      when :middle
+        @@definitions.merge(:endian => endians)
+      else
+        raise ArgumentError, "Unknown endian option '#{endian}'"
+      end
+    end
+
+    private
+
+    def tokenize(text, options)
+      text = pre_normalize(text)
+      tokens = text.split(' ').map { |word| Token.new(word) }
+      [Repeater, Grabber, Pointer, Scalar, Ordinal, Separator, Sign, TimeZone].each do |tok|
+        tok.scan(tokens, options)
+      end
+      tokens.select { |token| token.tagged? }
+    end
+
+    def tokens_to_span(tokens, options)
+      definitions = definitions(options)
+
+      (definitions[:endian] + definitions[:date]).each do |handler|
+        if handler.match(tokens, definitions)
+          good_tokens = tokens.select { |o| !o.get_tag Separator }
+          return handler.invoke(:date, good_tokens, self, options)
+        end
+      end
+
+      definitions[:anchor].each do |handler|
+        if handler.match(tokens, definitions)
+          good_tokens = tokens.select { |o| !o.get_tag Separator }
+          return handler.invoke(:anchor, good_tokens, self, options)
+        end
+      end
+
+      definitions[:arrow].each do |handler|
+        if handler.match(tokens, definitions)
+          good_tokens = tokens.reject { |o| o.get_tag(SeparatorAt) || o.get_tag(SeparatorSlash) || o.get_tag(SeparatorDash) || o.get_tag(SeparatorComma) || o.get_tag(SeparatorAnd) }
+          return handler.invoke(:arrow, good_tokens, self, options)
+        end
+      end
+
+      definitions[:narrow].each do |handler|
+        if handler.match(tokens, definitions)
+          return handler.invoke(:narrow, tokens, self, options)
+        end
+      end
+
+      puts "-none" if Chronic.debug
+      return nil
+    end
+  end
+end

data/lib/chronic/pointer.rb

@@ -1,20 +1,22 @@
 module Chronic
   class Pointer < Tag
 
-    # Scan an Array of {Token}s and apply any necessary Pointer tags to
-    # each token
+    # Scan an Array of Token objects 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
+    # tokens - An Array of tokens to scan.
+    # options - The Hash of options specified in Chronic::parse.
+    #
+    # Returns an Array of tokens.
     def self.scan(tokens, options)
       tokens.each do |token|
         if t = scan_for_all(token) then token.tag(t) end
       end
     end
 
-    # @param [Token] token
-    # @return [Pointer, nil]
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Pointer object.
     def self.scan_for_all(token)
       scan_for token, self,
       {

data/lib/chronic/repeater.rb

@@ -1,73 +1,78 @@
 module Chronic
   class Repeater < Tag
 
-    # Scan an Array of {Token}s and apply any necessary Repeater tags to
-    # each token
+    # Scan an Array of Token objects 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
+    # tokens - An Array of tokens to scan.
+    # options - The Hash of options specified in Chronic::parse.
+    #
+    # Returns an Array of tokens.
     def self.scan(tokens, options)
       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
+        if t = scan_for_season_names(token, options) then token.tag(t); next end
+        if t = scan_for_month_names(token, options) then token.tag(t); next end
+        if t = scan_for_day_names(token, options) then token.tag(t); next end
+        if t = scan_for_day_portions(token, options) then token.tag(t); next end
+        if t = scan_for_times(token, options) then token.tag(t); next end
+        if t = scan_for_units(token, options) then token.tag(t); next end
       end
     end
 
-    # @param [Token] token
-    # @return [RepeaterSeasonName, nil]
-    def self.scan_for_season_names(token)
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Repeater object.
+    def self.scan_for_season_names(token, options = {})
       scan_for token, RepeaterSeasonName,
       {
         /^springs?$/ => :spring,
         /^summers?$/ => :summer,
         /^(autumn)|(fall)s?$/ => :autumn,
         /^winters?$/ => :winter
-      }
+      }, options
     end
 
-    # @param [Token] token
-    # @return [RepeaterMonthName, nil]
-    def self.scan_for_month_names(token)
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Repeater object.
+    def self.scan_for_month_names(token, options = {})
       scan_for token, RepeaterMonthName,
       {
-        /^jan\.?(uary)?$/ => :january,
-        /^feb\.?(ruary)?$/ => :february,
-        /^mar\.?(ch)?$/ => :march,
-        /^apr\.?(il)?$/ => :april,
+        /^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
-      }
+        /^jun[:\.]?e?$/ => :june,
+        /^jul[:\.]?y?$/ => :july,
+        /^aug[:\.]?(ust)?$/ => :august,
+        /^sep[:\.]?(t[:\.]?|tember)?$/ => :september,
+        /^oct[:\.]?(ober)?$/ => :october,
+        /^nov[:\.]?(ember)?$/ => :november,
+        /^dec[:\.]?(ember)?$/ => :december
+      }, options
     end
 
-    # @param [Token] token
-    # @return [RepeaterDayName, nil]
-    def self.scan_for_day_names(token)
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Repeater object.
+    def self.scan_for_day_names(token, options = {})
       scan_for token, RepeaterDayName,
       {
         /^m[ou]n(day)?$/ => :monday,
         /^t(ue|eu|oo|u|)s?(day)?$/ => :tuesday,
         /^we(d|dnes|nds|nns)(day)?$/ => :wednesday,
-        /^th(u(?:rs)?|ers)(day)?$/ => :thursday,
+        /^th(u|ur|urs|ers)(day)?$/ => :thursday,
         /^fr[iy](day)?$/ => :friday,
         /^sat(t?[ue]rday)?$/ => :saturday,
         /^su[nm](day)?$/ => :sunday
-      }
+      }, options
     end
 
-    # @param [Token] token
-    # @return [RepeaterDayPortion, nil]
-    def self.scan_for_day_portions(token)
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Repeater object.
+    def self.scan_for_day_portions(token, options = {})
       scan_for token, RepeaterDayPortion,
       {
         /^ams?$/ => :am,
@@ -76,18 +81,20 @@ module Chronic
         /^afternoons?$/ => :afternoon,
         /^evenings?$/ => :evening,
         /^(night|nite)s?$/ => :night
-      }
+      }, options
     end
 
-    # @param [Token] token
-    # @return [RepeaterTime, nil]
-    def self.scan_for_times(token)
-      scan_for token, RepeaterTime, /^\d{1,2}(:?\d{2})?([\.:]?\d{2})?$/
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Repeater object.
+    def self.scan_for_times(token, options = {})
+      scan_for token, RepeaterTime, /^\d{1,2}(:?\d{1,2})?([\.:]?\d{1,2}([\.:]\d{1,6})?)?$/, options
     end
 
-    # @param [Token] token
-    # @return [Repeater] A new instance of a subclass of Repeater
-    def self.scan_for_units(token)
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Repeater object.
+    def self.scan_for_units(token, options = {})
       {
         /^years?$/ => :year,
         /^seasons?$/ => :season,
@@ -97,14 +104,17 @@ module Chronic
         /^weekends?$/ => :weekend,
         /^(week|business)days?$/ => :weekday,
         /^days?$/ => :day,
+	      /^hrs?$/ => :hour,
         /^hours?$/ => :hour,
+	      /^mins?$/ => :minute,
         /^minutes?$/ => :minute,
+	      /^secs?$/ => :second,
         /^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)
+          return klass.new(symbol, options)
         end
       end
       return nil
@@ -132,4 +142,4 @@ module Chronic
       'repeater'
     end
   end
-end
+end