gitlab-chronic 0.10.4 → 0.10.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f25bcc92f81d5633ffe7fa39e82b9997b7f0a88e4edfdaf1ad6a64b590c620f1
-  data.tar.gz: 960db7245d7a8a44dcf7512d66a120c5f0ce4c2cbe57b04a7b2f56e54a91b525
+  metadata.gz: 2b5a569ed8fd73d35d0726a7cb2f19f1ca3507543032bff4ca3f1aa73e1ba94f
+  data.tar.gz: 15f9949677fc421bf44def4fbf0da85928847e4918d4375657cf43c64f3f92fe
 SHA512:
-  metadata.gz: ae2b083127378b81b41e61322f4f61eddf41c3896ce064e3587c6df836cfc045395ba41ada4892b2c60ff12ca6ace925ee664820c9ac389db96da61a9e3b3dba
-  data.tar.gz: c591716552c0215495d942059fc3d8fa43eb4346b7ff1d5bc1da2c80ea07fecd63d8edc8093252bc536a2e85f3dea2bdaa7452c6d2ea9f82672bf39a9ea7b197
+  metadata.gz: d8ae6e9b8292042fce47b1125f2fd11aab058e45c5ab00fe01fdee2e8b8dddcc062fd505f1de80bc7a05fcc04c329e3229746bcbfaaa07b5d3d82ad7161a1a09
+  data.tar.gz: 727012bcb6c52dcd35e3f87ef099d50e27d7ab7b7c719a8f21d25e4ab802c06b3aa70a1acb790fa376efb2851d2c2d8e03c33539e3c03e51f33b90f04893044f

data/.gitignore

@@ -1,6 +1,5 @@
 *.rbc
 .yardoc
-/.bundle/
 /pkg/
 /coverage/
 /doc/

data/.travis.yml

@@ -1,10 +1,8 @@
 language: ruby
 rvm:
-  - 2.4.1
-  - 2.3
-  - 2.2
-  - 2.1
-  - 2.0.0
   - 1.9.3
+  - 1.9.2
+  - 1.8.7
   - jruby-19mode
-  - rbx-2
+  - jruby-18mode
+  - rbx-19mode

data/HISTORY.md

@@ -1,5 +1,9 @@
 ## --- Begin gitlab-chronic changes ---
 
+# 0.10.5 / 2019-11-25
+
+* Revert changes made between v0.10.2..master ((https://gitlab.com/gitlab-org/gitlab-chronic/merge_requests/7)
+
 # 0.10.4 / 2019-11-24
 
 * Rename chronic -> gitlab-chronic (https://gitlab.com/gitlab-org/gitlab-chronic/merge_requests/5)

data/README.md

@@ -57,7 +57,7 @@ Chronic can parse a huge variety of date and time formats. Following is a
 small sample of strings that will be properly parsed. Parsing is case
 insensitive and will handle common abbreviations and misspellings.
 
-#### Simple
+Simple
 
 * thursday
 * november
@@ -89,7 +89,7 @@ insensitive and will handle common abbreviations and misspellings.
 * afternoon yesterday
 * thursday last week
 
-#### Complex
+Complex
 
 * 3 years ago
 * a year ago
@@ -108,7 +108,7 @@ insensitive and will handle common abbreviations and misspellings.
 * fourteenth of june 2010 at eleven o'clock in the evening
 * may seventh '97 at three in the morning
 
-#### Specific Dates
+Specific Dates
 
 * January 5
 * 22nd of june
@@ -133,14 +133,12 @@ insensitive and will handle common abbreviations and misspellings.
 * 17:00
 * 0800
 
-#### Specific Times (many of the above with an added time)
+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
-* 2013-08-01T19:30:00.345-07:00
-* 2013-08-01T19:30:00.34-07:00
 * etc
 
 
@@ -163,7 +161,7 @@ class to get full time zone support.
 
 Chronic uses Ruby's built in Time class for all time storage and computation.
 Because of this, only times that the Time class can handle will be properly
-parsed. Parsing for times outside of this range will simply return `nil`.
+parsed. Parsing for times outside of this range will simply return nil.
 Support for a wider range of times is planned for a future release.
 
 
@@ -177,10 +175,9 @@ The best way to get your changes merged back into core is as follows:
 
 1. Clone down your fork
 1. Create a thoughtfully named topic branch to contain your change
-1. Install the development dependencies by running `bundle install`
 1. Hack away
-1. Add tests and make sure everything still passes by running `bundle exec rake`
-1. Ensure your tests pass in multiple timezones. ie `TZ=utc bundle exec rake` `TZ=BST bundle exec rake`
+1. Add tests and make sure everything still passes by running `rake`
+1. Ensure your tests pass in multiple timezones. ie `TZ=utc rake` `TZ=BST rake`
 1. If you are adding new functionality, document it in the README
 1. Do not change the version number, we will do that on our end
 1. If necessary, rebase your commits into logical chunks, without errors

data/chronic.gemspec

@@ -1,5 +1,5 @@
 $:.unshift File.expand_path('../lib', __FILE__)
-require 'chronic/version'
+require 'gitlab-chronic'
 
 Gem::Specification.new do |s|
   s.name = 'gitlab-chronic'

data/lib/chronic/date.rb

@@ -35,19 +35,20 @@ module Chronic
     }
 
     # Checks if given number could be day
-    def self.could_be_day?(day, width = nil)
-      day >= 1 && day <= 31 && (width.nil? || width <= 2)
+    def self.could_be_day?(day)
+      day >= 1 && day <= 31
     end
 
     # Checks if given number could be month
-    def self.could_be_month?(month, width = nil)
-      month >= 1 && month <= 12 && (width.nil? || width <= 2)
+    def self.could_be_month?(month)
+      month >= 1 && month <= 12
     end
 
     # Checks if given number could be year
-    def self.could_be_year?(year, width = nil)
-      year >= 0 && year <= 9999 && (width.nil? || width == 2 || width == 4)
+    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.

data/lib/chronic/{tags/grabber.rb → grabber.rb}

@@ -10,15 +10,19 @@ module Chronic
     # Returns an Array of Token objects.
     def self.scan(tokens, options)
       tokens.each do |token|
-        token.tag scan_for(token, self, patterns, options)
+        if t = scan_for_all(token) then token.tag(t); next end
       end
     end
 
-    def self.patterns
-      @@patterns ||= {
-        'last' => :last,
-        'this' => :this,
-        'next' => :next
+    # token - The Token object to scan.
+    #
+    # Returns a new Grabber object.
+    def self.scan_for_all(token)
+      scan_for token, self,
+      {
+        /last/ => :last,
+        /this/ => :this,
+        /next/ => :next
       }
     end
 

data/lib/chronic/handlers.rb

@@ -8,7 +8,6 @@ module Chronic
       span = month.this(options[:context])
       year, month = span.begin.year, span.begin.month
       day_start = Chronic.time_class.local(year, month, day)
-      day_start = Chronic.time_class.local(year + 1, month, day) if options[:context] == :future && day_start < now
 
       day_or_time(day_start, time_tokens, options)
     end
@@ -110,19 +109,6 @@ module Chronic
       handle_m_d(month, day, tokens[token_range], options)
     end
 
-    # Handle scalar-year/repeater-quarter-name
-    def handle_sy_rqn(tokens, options)
-      handle_rqn_sy(tokens[0..1].reverse, options)
-    end
-
-    # Handle repeater-quarter-name/scalar-year
-    def handle_rqn_sy(tokens, options)
-      year = tokens[1].get_tag(ScalarYear).type
-      quarter_tag = tokens[0].get_tag(RepeaterQuarterName)
-      quarter_tag.start = Chronic.construct(year)
-      quarter_tag.this(:none)
-    end
-
     # Handle repeater-month-name/scalar-year
     def handle_rmn_sy(tokens, options)
       month = tokens[0].get_tag(RepeaterMonthName).index
@@ -252,13 +238,7 @@ module Chronic
 
       begin
         day_start = Chronic.time_class.local(year, month, day)
-
-        if options[:context] == :future && day_start < now
-          day_start = Chronic.time_class.local(year + 1, month, day)
-        elsif options[:context] == :past && day_start > now
-          day_start = Chronic.time_class.local(year - 1, month, day)
-        end
-
+        day_start = Chronic.time_class.local(year + 1, month, day) if options[:context] == :future && day_start < now
         day_or_time(day_start, time_tokens, options)
       rescue ArgumentError
         nil
@@ -470,11 +450,6 @@ module Chronic
       handle_srp(tokens, anchor_span, options)
     end
 
-    # Handle repeater/scalar/repeater/pointer
-    def handle_rmn_s_r_p(tokens, options)
-      handle_s_r_p_a(tokens[1..3] + tokens[0..0], options)
-    end
-
     def handle_s_r_a_s_r_p_a(tokens, options)
       anchor_span = get_anchor(tokens[4..tokens.size - 1], options)
 
@@ -553,7 +528,7 @@ module Chronic
       when :next
         outer_span = head.next(:future)
       else
-        raise 'Invalid grabber'
+        raise "Invalid grabber"
       end
 
       if Chronic.debug

data/lib/chronic/mini_date.rb

@@ -8,7 +8,7 @@ module Chronic
 
     def initialize(month, day)
       unless (1..12).include?(month)
-        raise ArgumentError, '1..12 are valid months'
+        raise ArgumentError, "1..12 are valid months"
       end
 
       @month = month
@@ -35,4 +35,4 @@ module Chronic
       @month == other.month and @day == other.day
     end
   end
-end
+end

data/lib/chronic/numerizer.rb

@@ -0,0 +1,130 @@
+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'],
+      ['twelfth', '12'],
+      ['twentieth', '20'],
+      ['thirtieth', '30'],
+      ['fourtieth', '40'],
+      ['fiftieth', '50'],
+      ['sixtieth', '60'],
+      ['seventieth', '70'],
+      ['eightieth', '80'],
+      ['ninetieth', '90']
+    ]
+
+    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) { $1.empty? ? bp[1] : '<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/{tags/ordinal.rb → ordinal.rb}

@@ -11,17 +11,14 @@ module Chronic
     def self.scan(tokens, options)
       tokens.each_index do |i|
         if tokens[i].word =~ /^(\d+)(st|nd|rd|th|\.)$/
-          width = $1.length
-          ordinal = $1.to_i
-          tokens[i].tag(Ordinal.new(ordinal, width))
-          tokens[i].tag(OrdinalDay.new(ordinal, width)) if Chronic::Date::could_be_day?(ordinal, width)
-          tokens[i].tag(OrdinalMonth.new(ordinal, width)) if Chronic::Date::could_be_month?(ordinal, width)
-          if Chronic::Date::could_be_year?(ordinal, width)
-            year = Chronic::Date::make_year(ordinal, options[:ambiguous_year_future_bias])
-            tokens[i].tag(OrdinalYear.new(year.to_i, width))
-          end
-        elsif tokens[i].word =~ /^second$/
-          tokens[i].tag(Ordinal.new(2, 1))
+            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

data/lib/chronic/parser.rb

@@ -1,4 +1,3 @@
-require 'chronic/dictionary'
 require 'chronic/handlers'
 
 module Chronic
@@ -10,7 +9,6 @@ module Chronic
       :context => :future,
       :now => nil,
       :hours24 => nil,
-      :week_start => :sunday,
       :guess => true,
       :ambiguous_time_range => 6,
       :endian_precedence    => [:middle, :little],
@@ -27,9 +25,6 @@ module Chronic
     #        :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.
-    #        :week_start - By default, the parser assesses weeks start on
-    #                  sunday but you can change this value to :monday if
-    #                  needed.
     #        :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
@@ -55,9 +50,8 @@ module Chronic
     #                 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 = {})
-      validate_options!(options)
       @options = DEFAULT_OPTIONS.merge(options)
-      @now = options[:now] || Chronic.time_class.now
+      @now = options.delete(:now) || Chronic.time_class.now
     end
 
     # Parse "text" with the given options
@@ -94,35 +88,22 @@ module Chronic
     # Returns a new String ready for Chronic to parse.
     def pre_normalize(text)
       text = text.to_s.downcase
-      text.gsub!(/\b(\d{1,2})\.(\d{1,2})\.(\d{4})\b/, '\3 / \2 / \1')
+      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+)\-(\d{2}:?\d{2})\b/, '\1tzminus\2')
+      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!(/'(\d{2})\b/) do
-        number = $1.to_i
-
-        if Chronic::Date::could_be_year?(number)
-          Chronic::Date::make_year(number, options[:ambiguous_year_future_bias])
-        else
-          number
-        end
-      end
       text.gsub!(/['"]/, '')
       text.gsub!(/,/, ' ')
       text.gsub!(/^second /, '2nd ')
-      text.gsub!(/\bsecond (of|day|month|hour|minute|second|quarter)\b/, '2nd \1')
-      text.gsub!(/\bthird quarter\b/, '3rd q')
-      text.gsub!(/\bfourth quarter\b/, '4th q')
-      text.gsub!(/quarters?(\s+|$)(?!to|till|past|after|before)/, 'q\1')
+      text.gsub!(/\bsecond (of|day|month|hour|minute|second)\b/, '2nd \1')
       text = Numerizer.numerize(text)
-      text.gsub!(/\b(\d)(?:st|nd|rd|th)\s+q\b/, 'q\1')
       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|midday\b/, '12:00pm')
+      text.gsub!(/\bnoon\b/, '12:00pm')
       text.gsub!(/\bmidnight\b/, '24:00')
       text.gsub!(/\bnow\b/, 'this second')
       text.gsub!('quarter', '15')
@@ -163,22 +144,87 @@ module Chronic
     #
     # Returns a Hash of Handler definitions.
     def definitions(options = {})
-      SpanDictionary.new(options).definitions
-    end
+      options[:endian_precedence] ||= [:middle, :little]
 
-    private
+      @@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)
+        ],
 
-    def validate_options!(options)
-      given = options.keys.map(&:to_s).sort
-      allowed = DEFAULT_OPTIONS.keys.map(&:to_s).sort
-      non_permitted = given - allowed
-      raise ArgumentError, "Unsupported option(s): #{non_permitted.join(', ')}" if non_permitted.any?
+        :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 = Tokenizer::tokenize(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
@@ -215,7 +261,7 @@ module Chronic
         end
       end
 
-      puts '-none' if Chronic.debug
+      puts "-none" if Chronic.debug
       return nil
     end
   end