chronic 0.9.1 → 0.10.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7033fa51e89c8552e935aab7ee0bb5673338d063
-  data.tar.gz: 21a09efad9e8da2dcd3ed32a5c8605707f36abc7
+  metadata.gz: d0bcdd2460eb86f8898212a9eca5e325c9aa5e61
+  data.tar.gz: d8abd19da58e28473139b8f137991cb0ee150c49
 SHA512:
-  metadata.gz: f3d63e888e712dad2b0d4c70d11688607e56a3d1b4ac11632e14b3f23a57f21a2fd32403f50cf13002a9859607a89e6521b5c39f4ec003edd5631791cf7cf409
-  data.tar.gz: 9e2d80dcf087643ce865ede613dbd2d006942b1986e46c02f75b012711ee79bb74f0b576ba812d8b54ab599411213548effc036cc888c97b82c70fdf21627365
+  metadata.gz: 04bfd4f32ce8f8ef6585042425ea64cc95d07998287fb16fa45b8d0a06d5dd48f8b85e6fecbf00e69101e560f21527ef6539a8994a9457357d25c2c832c7b87f
+  data.tar.gz: 87db3c22292ed9d5a22ecc84e6b14dafb2ed1c7a4c2f829873593b86b37707999adfaf43a5e0d801daffaaec9c7b599beade2d366d108c60bf2e8989998ed4b4

data/.gitignore

@@ -1,6 +1,6 @@
-pkg
 *.rbc
-rdoc
 .yardoc
-doc
-tags
+/pkg/
+/coverage/
+/doc/
+/tags/

data/HISTORY.md

@@ -1,3 +1,24 @@
+# 0.10.2 / 2013-09-09
+
+* Fix 1.8.7 support (due to be dropped in 0.11.0)
+* Bugfix for times with negative zones
+
+# 0.10.1 / 2013-08-27
+
+* Support `ActiveSupport::TimeZone` (#209, #208)
+
+# 0.10.0 / 2013-08-25
+
+* Chronic will parse subseconds correctly
+  for all supported date/time formats (#195, #198 and #200)
+* Support for date format: dd.mm.yyyy (#197)
+* Option `:hours24` to parse as 24 hour clock (#201 and #202)
+* `:guess` option allows to specify which part of Span to return.
+  (accepted values `false`,`true`,`:begin`, `:middle`, `:end`)
+* Replace `rcov` with `SimpleCov` for coverage generation
+* Add more tests
+* Various changes in codebase (#202 and #206)
+
 # 0.9.1 / 2013-02-25
 
 * Ensure Chronic strips periods from day portions (#173)

data/README.md

@@ -37,8 +37,15 @@ Chronic.parse('may 27th', :guess => false)
 
 Chronic.parse('6/4/2012', :endian_precedence => :little)
   #=> Fri Apr 06 00:00:00 PDT 2012
+
+Chronic.parse('INVALID DATE')
+  #=> nil
 ```
 
+If the parser can find a date or time, either a Time or Chronic::Span
+will be returned (depending on the value of `:guess`). If no
+date or time can be found, `nil` will be returned.
+
 See `Chronic.parse` for detailed usage instructions.
 
 ## Examples
@@ -128,6 +135,7 @@ Specific Times (many of the above with an added time)
 * January 5 at 7pm
 * 22nd of june at 8am
 * 1979-05-27 05:00:00
+* 03/01/2012 07:25:09.234567
 * etc
 
 

data/Rakefile

@@ -5,17 +5,37 @@ def version
   contents[/VERSION = "([^"]+)"/, 1]
 end
 
-task :test do
+def do_test
   $:.unshift './test'
   Dir.glob('test/test_*.rb').each { |t| require File.basename(t) }
 end
 
-desc "Generate RCov test coverage and open in your browser"
+def open_command
+  case RUBY_PLATFORM
+  when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+    'start'
+  when /darwin|mac os/
+    'open'
+  else
+    'xdg-open'
+  end
+end
+
+task :test do
+  do_test
+end
+
+desc "Generate SimpleCov test coverage and open in your browser"
 task :coverage do
-  require 'rcov'
-  sh "rm -fr coverage"
-  sh "rcov test/test_*.rb"
-  sh "open coverage/index.html"
+  require 'simplecov'
+  FileUtils.rm_rf("./coverage")
+  SimpleCov.command_name 'Unit Tests'
+  SimpleCov.at_exit do
+    SimpleCov.result.format!
+    sh "#{open_command} #{SimpleCov.coverage_path}/index.html"
+  end
+  SimpleCov.start
+  do_test
 end
 
 desc "Open an irb session preloaded with this library"
@@ -38,9 +58,9 @@ end
 
 desc "Build a gem from the gemspec"
 task :build do
-  sh "mkdir -p pkg"
+  FileUtils.mkdir_p "pkg"
   sh "gem build chronic.gemspec"
-  sh "mv chronic-#{version}.gem pkg"
+  FileUtils.mv("./chronic-#{version}.gem", "pkg")
 end
 
 task :default => :test

data/chronic.gemspec

@@ -8,13 +8,16 @@ Gem::Specification.new do |s|
   s.summary     = 'Natural language date/time parsing.'
   s.description = 'Chronic is a natural language date/time parser written in pure Ruby.'
   s.authors  = ['Tom Preston-Werner', 'Lee Jarvis']
-  s.email    = ['tom@mojombo.com', 'lee@jarvis.co']
+  s.email    = ['tom@mojombo.com', 'ljjarvis@gmail.com']
   s.homepage = 'http://github.com/mojombo/chronic'
+  s.license = 'MIT'
   s.rdoc_options = ['--charset=UTF-8']
   s.extra_rdoc_files = %w[README.md HISTORY.md LICENSE]
-  s.files = `git ls-files`.split("\n")
-  s.test_files = `git ls-files -- test`.split("\n")
+  s.files = `git ls-files`.split($/)
+  s.test_files = `git ls-files -- test`.split($/)
 
   s.add_development_dependency 'rake'
-  s.add_development_dependency 'minitest'
-end
+  s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'minitest', '~> 5.0'
+  s.add_development_dependency 'activesupport'
+end

data/lib/chronic/date.rb

@@ -0,0 +1,82 @@
+module Chronic
+  class Date
+    YEAR_MONTHS = 12
+    MONTH_DAYS        = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+    MONTH_DAYS_LEAP   = [nil, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+    YEAR_SECONDS      = 31_536_000 # 365 * 24 * 60 * 60
+    SEASON_SECONDS    =  7_862_400 #  91 * 24 * 60 * 60
+    MONTH_SECONDS     =  2_592_000 #  30 * 24 * 60 * 60
+    FORTNIGHT_SECONDS =  1_209_600 #  14 * 24 * 60 * 60
+    WEEK_SECONDS      =    604_800 #   7 * 24 * 60 * 60
+    WEEKEND_SECONDS   =    172_800 #   2 * 24 * 60 * 60
+    DAY_SECONDS       =     86_400 #       24 * 60 * 60
+    MONTHS = {
+      :january => 1,
+      :february => 2,
+      :march => 3,
+      :april => 4,
+      :may => 5,
+      :june => 6,
+      :july => 7,
+      :august => 8,
+      :september => 9,
+      :october => 10,
+      :november => 11,
+      :december => 12
+    }
+    DAYS = {
+      :sunday => 0,
+      :monday => 1,
+      :tuesday => 2,
+      :wednesday => 3,
+      :thursday => 4,
+      :friday => 5,
+      :saturday => 6
+    }
+
+    # Checks if given number could be day
+    def self.could_be_day?(day)
+      day >= 1 && day <= 31
+    end
+
+    # Checks if given number could be month
+    def self.could_be_month?(month)
+      month >= 1 && month <= 12
+    end
+
+    # Checks if given number could be year
+    def self.could_be_year?(year)
+      year >= 1 && year <= 9999
+    end
+
+    # Build a year from a 2 digit suffix.
+    #
+    # year - The two digit Integer year to build from.
+    # bias - The Integer amount of future years to bias.
+    #
+    # Examples:
+    #
+    #   make_year(96, 50) #=> 1996
+    #   make_year(79, 20) #=> 2079
+    #   make_year(00, 50) #=> 2000
+    #
+    # Returns The Integer 4 digit year.
+    def self.make_year(year, bias)
+      return year if year.to_s.size > 2
+      start_year = Chronic.time_class.now.year - bias
+      century = (start_year / 100) * 100
+      full_year = century + year
+      full_year += 100 if full_year < start_year
+      full_year
+    end
+
+    def self.month_overflow?(year, month, day)
+      if ::Date.leap?(year)
+        day > Date::MONTH_DAYS_LEAP[month]
+      else
+        day > Date::MONTH_DAYS[month]
+      end
+    end
+
+  end
+end

data/lib/chronic/handler.rb

@@ -19,39 +19,48 @@ module Chronic
     # Returns true if a match is found.
     def match(tokens, definitions)
       token_index = 0
+      @pattern.each do |elements|
+        was_optional = false
+        elements = [elements] unless elements.is_a?(Array)
+
+        elements.each_index do |i|
+          name = elements[i].to_s
+          optional = name[-1, 1] == '?'
+          name = name.chop if optional
+
+          case elements[i]
+          when Symbol
+            if tags_match?(name, tokens, token_index)
+              token_index += 1
+              break
+            else
+              if optional
+                was_optional = true
+                next
+              elsif i + 1 < elements.count
+                next
+              else
+                return false unless was_optional
+              end
+            end
 
-      @pattern.each do |element|
-        name = element.to_s
-        optional = name[-1, 1] == '?'
-        name = name.chop if optional
+          when String
+            return true if optional && token_index == tokens.size
 
-        case element
-        when Symbol
-          if tags_match?(name, tokens, token_index)
-            token_index += 1
-            next
-          else
-            if optional
-              next
+            if definitions.key?(name.to_sym)
+              sub_handlers = definitions[name.to_sym]
             else
-              return false
+              raise "Invalid subset #{name} specified"
             end
-          end
-        when String
-          return true if optional && token_index == tokens.size
 
-          if definitions.key?(name.to_sym)
-            sub_handlers = definitions[name.to_sym]
+            sub_handlers.each do |sub_handler|
+              return true if sub_handler.match(tokens[token_index..tokens.size], definitions)
+            end
           else
-            raise "Invalid subset #{name} specified"
-          end
-
-          sub_handlers.each do |sub_handler|
-            return true if sub_handler.match(tokens[token_index..tokens.size], definitions)
+            raise "Invalid match type: #{elements[i].class}"
           end
-        else
-          raise "Invalid match type: #{element.class}"
         end
+
       end
 
       return false if token_index != tokens.size

data/lib/chronic/handlers.rb

@@ -134,6 +134,8 @@ module Chronic
     def handle_generic(tokens, options)
       t = Chronic.time_class.parse(options[:text])
       Span.new(t, t + 1)
+    rescue ArgumentError => e
+      raise e unless e.message =~ /out of range/
     end
 
     # Handle repeater-month-name/scalar-day/scalar-year
@@ -304,6 +306,23 @@ module Chronic
       end
     end
 
+    # Handle RepeaterDayName RepeaterMonthName OrdinalDay ScalarYear
+    def handle_rdn_rmn_od_sy(tokens, options)
+      month = tokens[1].get_tag(RepeaterMonthName)
+      day = tokens[2].get_tag(OrdinalDay).type
+      year = tokens[3].get_tag(ScalarYear).type
+
+      return if month_overflow?(year, month.index, day)
+
+      begin
+        start_time = Chronic.time_class.local(year, month.index, day)
+        end_time = time_with_rollover(year, month.index, day + 1)
+        Span.new(start_time, end_time)
+      rescue ArgumentError
+        nil
+      end
+    end
+
     # Handle RepeaterDayName OrdinalDay
     def handle_rdn_od(tokens, options)
       day = tokens[1].get_tag(OrdinalDay).type
@@ -476,9 +495,9 @@ module Chronic
     def day_or_time(day_start, time_tokens, options)
       outer_span = Span.new(day_start, day_start + (24 * 60 * 60))
 
-      if !time_tokens.empty?
+      unless time_tokens.empty?
         self.now = outer_span.begin
-        get_anchor(dealias_and_disambiguate_times(time_tokens, options), options)
+        get_anchor(dealias_and_disambiguate_times(time_tokens, options), options.merge(:context => :future))
       else
         outer_span
       end
@@ -525,7 +544,7 @@ module Chronic
     end
 
     def month_overflow?(year, month, day)
-      if Date.leap?(year)
+      if ::Date.leap?(year)
         day > RepeaterMonth::MONTH_DAYS_LEAP[month - 1]
       else
         day > RepeaterMonth::MONTH_DAYS[month - 1]

data/lib/chronic/ordinal.rb

@@ -9,26 +9,16 @@ module Chronic
     #
     # 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
-
-    # token - The Token object we want to scan.
-    #
-    # Returns a new Ordinal object.
-    def self.scan_for_ordinals(token)
-      Ordinal.new($1.to_i) if token.word =~ /^(\d*)(st|nd|rd|th)$/
-    end
-
-    # token - The Token object we want to scan.
-    #
-    # Returns a new Ordinal object.
-    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
@@ -44,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

@@ -8,6 +8,7 @@ module Chronic
     DEFAULT_OPTIONS = {
       :context => :future,
       :now => nil,
+      :hours24 => nil,
       :guess => true,
       :ambiguous_time_range => 6,
       :endian_precedence    => [:middle, :little],
@@ -23,10 +24,13 @@ module Chronic
     #                   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.
+    #                 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
@@ -58,9 +62,7 @@ module Chronic
 
       puts "+#{'-' * 51}\n| #{tokens}\n+#{'-' * 51}" if Chronic.debug
 
-      if span
-        options[:guess] ? guess(span) : span
-      end
+      guess(span, options[:guess]) if span
     end
 
     # Clean up the specified text ready for parsing.
@@ -86,14 +88,16 @@ module Chronic
     # 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!(/\-(\d{2}:?\d{2})\b/, 'tzminus\1')
       text.gsub!(/([\/\-\,\@])/) { ' ' + $1 + ' ' }
       text.gsub!(/(?:^|\s)0(\d+:\d+\s*pm?\b)/, ' \1')
       text.gsub!(/\btoday\b/, 'this day')
@@ -126,12 +130,11 @@ module Chronic
     # span - The Chronic::Span object to calcuate a guess from.
     #
     # Returns a new Time object.
-    def guess(span)
-      if span.width > 1
-        span.begin + (span.width / 2)
-      else
-        span.begin
-      end
+    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
@@ -149,19 +152,21 @@ module Chronic
         ],
 
         :date => [
-          Handler.new([:repeater_day_name, :repeater_month_name, :scalar_day, :repeater_time, :separator_slash_or_dash?, :time_zone, :scalar_year], :handle_generic),
+          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_or_dash, :scalar_month, :separator_slash_or_dash, :scalar_day, :repeater_time, :time_zone], :handle_generic),
+          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_or_dash?, :scalar_day, :separator_at?, 'time?'], :handle_rmn_sd),
+          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),
@@ -171,12 +176,12 @@ module Chronic
           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_or_dash?, :repeater_month_name, :separator_at?, 'time?'], :handle_sd_rmn),
-          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_year, :separator_slash_or_dash, :scalar_month], :handle_sy_sm),
-          Handler.new([:scalar_month, :separator_slash_or_dash, :scalar_year], :handle_sm_sy),
-          Handler.new([:scalar_day, :separator_slash_or_dash, :repeater_month_name, :separator_slash_or_dash, :scalar_year, :repeater_time?], :handle_sm_rmn_sy),
-          Handler.new([:scalar_year, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :scalar?, :time_zone], :handle_generic),
+          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 => [
@@ -199,10 +204,10 @@ module Chronic
       }
 
       endians = [
-        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_month, :separator_slash_or_dash, :scalar_day, :separator_at?, 'time?'], :handle_sm_sd),
-        Handler.new([:scalar_day, :separator_slash_or_dash, :scalar_month, :separator_at?, 'time?'], :handle_sd_sm),
-        Handler.new([:scalar_day, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :scalar_year, :separator_at?, 'time?'], :handle_sd_sm_sy)
+        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
@@ -220,7 +225,7 @@ module Chronic
     def tokenize(text, options)
       text = pre_normalize(text)
       tokens = text.split(' ').map { |word| Token.new(word) }
-      [Repeater, Grabber, Pointer, Scalar, Ordinal, Separator, TimeZone].each do |tok|
+      [Repeater, Grabber, Pointer, Scalar, Ordinal, Separator, Sign, TimeZone].each do |tok|
         tok.scan(tokens, options)
       end
       tokens.select { |token| token.tagged? }
@@ -245,7 +250,7 @@ module Chronic
 
       definitions[:arrow].each do |handler|
         if handler.match(tokens, definitions)
-          good_tokens = tokens.reject { |o| o.get_tag(SeparatorAt) || o.get_tag(SeparatorSlashOrDash) || o.get_tag(SeparatorComma) || o.get_tag(SeparatorAnd) }
+          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

data/lib/chronic/repeater.rb

@@ -10,32 +10,32 @@ module Chronic
     # 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
 
     # token - The Token object we want to scan.
     #
     # Returns a new Repeater object.
-    def self.scan_for_season_names(token)
+    def self.scan_for_season_names(token, options = {})
       scan_for token, RepeaterSeasonName,
       {
         /^springs?$/ => :spring,
         /^summers?$/ => :summer,
         /^(autumn)|(fall)s?$/ => :autumn,
         /^winters?$/ => :winter
-      }
+      }, options
     end
 
     # token - The Token object we want to scan.
     #
     # Returns a new Repeater object.
-    def self.scan_for_month_names(token)
+    def self.scan_for_month_names(token, options = {})
       scan_for token, RepeaterMonthName,
       {
         /^jan[:\.]?(uary)?$/ => :january,
@@ -50,13 +50,13 @@ module Chronic
         /^oct[:\.]?(ober)?$/ => :october,
         /^nov[:\.]?(ember)?$/ => :november,
         /^dec[:\.]?(ember)?$/ => :december
-      }
+      }, options
     end
 
     # token - The Token object we want to scan.
     #
     # Returns a new Repeater object.
-    def self.scan_for_day_names(token)
+    def self.scan_for_day_names(token, options = {})
       scan_for token, RepeaterDayName,
       {
         /^m[ou]n(day)?$/ => :monday,
@@ -66,13 +66,13 @@ module Chronic
         /^fr[iy](day)?$/ => :friday,
         /^sat(t?[ue]rday)?$/ => :saturday,
         /^su[nm](day)?$/ => :sunday
-      }
+      }, options
     end
 
     # token - The Token object we want to scan.
     #
     # Returns a new Repeater object.
-    def self.scan_for_day_portions(token)
+    def self.scan_for_day_portions(token, options = {})
       scan_for token, RepeaterDayPortion,
       {
         /^ams?$/ => :am,
@@ -81,20 +81,20 @@ module Chronic
         /^afternoons?$/ => :afternoon,
         /^evenings?$/ => :evening,
         /^(night|nite)s?$/ => :night
-      }
+      }, options
     end
 
     # token - The Token object we want to scan.
     #
     # Returns a new Repeater object.
-    def self.scan_for_times(token)
-      scan_for token, RepeaterTime, /^\d{1,2}(:?\d{1,2})?([\.:]?\d{1,2})?$/
+    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
 
     # token - The Token object we want to scan.
     #
     # Returns a new Repeater object.
-    def self.scan_for_units(token)
+    def self.scan_for_units(token, options = {})
       {
         /^years?$/ => :year,
         /^seasons?$/ => :season,
@@ -114,7 +114,7 @@ module Chronic
         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