chronic_2011 0.1.0

data/.gitignore

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

data/HISTORY.md

@@ -0,0 +1,4 @@
+# 0.1.0
+
+* Initial release
+* Forked from mjombo/chronic commit 5042ae55dc

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) Tom Preston-Werner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,180 @@
+Chronic
+=======
+
+## DESCRIPTION
+
+Chronic is a natural language date/time parser written in pure Ruby. See below
+for the wide variety of formats Chronic will parse.
+
+
+## INSTALLATION
+
+### RubyGems
+
+    $ [sudo] gem install chronic
+
+### GitHub
+
+    $ git clone git://github.com/mojombo/chronic.git
+    $ cd chronic && gem build chronic.gemspec
+    $ gem install chronic-<version>.gem
+
+
+## USAGE
+
+You can parse strings containing a natural language date using the
+`Chronic.parse` method.
+
+    require 'chronic'
+
+    Time.now   #=> Sun Aug 27 23:18:25 PDT 2006
+
+    Chronic.parse('tomorrow')
+      #=> Mon Aug 28 12:00:00 PDT 2006
+
+    Chronic.parse('monday', :context => :past)
+      #=> Mon Aug 21 12:00:00 PDT 2006
+
+    Chronic.parse('this tuesday 5:00')
+      #=> Tue Aug 29 17:00:00 PDT 2006
+
+    Chronic.parse('this tuesday 5:00', :ambiguous_time_range => :none)
+      #=> Tue Aug 29 05:00:00 PDT 2006
+
+    Chronic.parse('may 27th', :now => Time.local(2000, 1, 1))
+      #=> Sat May 27 12:00:00 PDT 2000
+
+    Chronic.parse('may 27th', :guess => false)
+      #=> Sun May 27 00:00:00 PDT 2007..Mon May 28 00:00:00 PDT 2007
+      
+    Chronic.parse('6/4/2012', :endian_precedence => :little)
+      #=> Fri Apr 06 00:00:00 PDT 2012
+      
+
+See `Chronic.parse` for detailed usage instructions.
+
+
+## EXAMPLES
+
+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
+
+* thursday
+* november
+* summer
+* friday 13:00
+* mon 2:35
+* 4pm
+* 6 in the morning
+* friday 1pm
+* sat 7 in the evening
+* yesterday
+* today
+* tomorrow
+* this tuesday
+* next month
+* last winter
+* this morning
+* last night
+* this second
+* yesterday at 4:00
+* last friday at 20:00
+* last week tuesday
+* tomorrow at 6:45pm
+* afternoon yesterday
+* thursday last week
+
+Complex
+
+* 3 years ago
+* 5 months before now
+* 7 hours ago
+* 7 days from now
+* 1 week hence
+* in 3 hours
+* 1 year ago tomorrow
+* 3 months ago saturday at 5:00 pm
+* 7 hours before tomorrow at noon
+* 3rd wednesday in november
+* 3rd month next year
+* 3rd thursday this september
+* 4th day last week
+* fourteenth of june 2010 at eleven o'clock in the evening
+* may seventh '97 at three in the morning
+
+Specific Dates
+
+* January 5
+* 22nd of june
+* 5th may 2017
+* February twenty first
+* dec 25
+* may 27th
+* October 2006
+* oct 06
+* jan 3 2010
+* february 14, 2004
+* february 14th, 2004
+* 3 jan 2000
+* 17 april 85
+* 5/27/1979
+* 27/5/1979
+* 05/06
+* 1979-05-27
+* Friday
+* 5
+* 4:00
+* 17:00
+* 0800
+
+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
+* etc
+
+
+## TIME ZONES
+
+Chronic allows you to set which Time class to use when constructing times. By
+default, the built in Ruby time class creates times in your system's local
+time zone. You can set this to something like ActiveSupport's
+[TimeZone](http://api.rubyonrails.org/classes/ActiveSupport/TimeZone.html)
+class to get full time zone support.
+
+    >> Time.zone = "UTC"
+    >> Chronic.time_class = Time.zone
+    >> Chronic.parse("June 15 2006 at 5:45 AM")
+    => Thu, 15 Jun 2006 05:45:00 UTC +00:00
+
+
+## LIMITATIONS
+
+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.
+Support for a wider range of times is planned for a future release.
+
+
+## CONTRIBUTE
+
+If you'd like to hack on Chronic, start by forking the repo on GitHub:
+
+https://github.com/mojombo/chronic
+
+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. Hack away
+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
+1. Push the branch up to GitHub
+1. Send a pull request for your branch

data/Rakefile

@@ -0,0 +1,46 @@
+require 'date'
+
+def version
+  contents = File.read File.expand_path('../lib/chronic.rb', __FILE__)
+  contents[/VERSION = "([^"]+)"/, 1]
+end
+
+task :test do
+  $:.unshift './test'
+  Dir.glob('test/test_*.rb').each { |t| require File.basename(t) }
+end
+
+desc "Generate RCov 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"
+end
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -Ilib -rchronic"
+end
+
+desc "Release Chronic version #{version}"
+task :release => :build do
+  unless `git branch` =~ /^\* master$/
+    puts "You must be on the master branch to release!"
+    exit!
+  end
+  sh "git commit --allow-empty -a -m 'Release #{version}'"
+  sh "git tag v#{version}"
+  sh "git push origin master"
+  sh "git push origin v#{version}"
+  sh "gem push pkg/chronic-#{version}.gem"
+end
+
+desc "Build a gem from the gemspec"
+task :build do
+  sh "mkdir -p pkg"
+  sh "gem build chronic.gemspec"
+  sh "mv chronic_2011-#{version}.gem pkg"
+end
+
+task :default => :test

data/chronic.gemspec

@@ -0,0 +1,18 @@
+$:.unshift File.expand_path('../lib', __FILE__)
+require 'chronic'
+
+Gem::Specification.new do |s|
+  s.name = 'chronic_2011'
+  s.version = Chronic::VERSION
+  s.date = '2012-05-16'
+  s.summary     = 'Natural language date/time parsing'
+  s.description = 'The original Chronic gem is a natural language date/time parser written in pure Ruby. This gem, Chronic 2011, returns a Date or Time depending on the user input.'
+  s.authors  = ['Jason Lew']
+  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.add_development_dependency 'rake'
+  s.add_development_dependency 'minitest'
+end

data/lib/chronic.rb

@@ -0,0 +1,117 @@
+require 'time'
+require 'date'
+
+# Parse natural language dates and times into Time or Chronic::Span objects.
+#
+# Examples:
+#
+#   require 'chronic'
+#
+#   Time.now   #=> Sun Aug 27 23:18:25 PDT 2006
+#
+#   Chronic.parse('tomorrow')
+#     #=> Mon Aug 28 12:00:00 PDT 2006
+#
+#   Chronic.parse('monday', :context => :past)
+#     #=> Mon Aug 21 12:00:00 PDT 2006
+#
+#   Chronic.parse('this tuesday 5:00')
+#     #=> Tue Aug 29 17:00:00 PDT 2006
+#
+#   Chronic.parse('this tuesday 5:00', :ambiguous_time_range => :none)
+#     #=> Tue Aug 29 05:00:00 PDT 2006
+#
+#   Chronic.parse('may 27th', :now => Time.local(2000, 1, 1))
+#     #=> Sat May 27 12:00:00 PDT 2000
+#
+#   Chronic.parse('may 27th', :guess => false)
+#     #=> Sun May 27 00:00:00 PDT 2007..Mon May 28 00:00:00 PDT 2007
+module Chronic
+  VERSION = "0.1.0"
+
+  class << self
+
+    # Returns true when debug mode is enabled.
+    attr_accessor :debug
+
+    # Examples:
+    #
+    #   require 'chronic'
+    #   require 'active_support/time'
+    #
+    #   Time.zone = 'UTC'
+    #   Chronic.time_class = Time.zone
+    #   Chronic.parse('June 15 2006 at 5:54 AM')
+    #     # => Thu, 15 Jun 2006 05:45:00 UTC +00:00
+    #
+    # Returns The Time class Chronic uses internally.
+    attr_accessor :time_class
+
+    # The current Time Chronic is using to base from.
+    #
+    # Examples:
+    #
+    #   Time.now #=> 2011-06-06 14:13:43 +0100
+    #   Chronic.parse('yesterday') #=> 2011-06-05 12:00:00 +0100
+    #
+    #   now = Time.local(2025, 12, 24)
+    #   Chronic.parse('tomorrow', :now => now) #=> 2025-12-25 12:00:00 +0000
+    #
+    # Returns a Time object.
+    attr_accessor :now
+  end
+
+  self.debug = true #jlew
+  self.time_class = Time
+  
+  autoload :Handler, 'chronic/handler'
+  autoload :Handlers, 'chronic/handlers'
+  autoload :MiniDate, 'chronic/mini_date'
+  autoload :Tag, 'chronic/tag'
+  autoload :Span, 'chronic/span'
+  autoload :Token, 'chronic/token'
+  autoload :Grabber, 'chronic/grabber'
+  autoload :Pointer, 'chronic/pointer'
+  autoload :Scalar, 'chronic/scalar'
+  autoload :Ordinal, 'chronic/ordinal'
+  autoload :OrdinalDay, 'chronic/ordinal'
+  autoload :Separator, 'chronic/separator'
+  autoload :TimeZone, 'chronic/time_zone'
+  autoload :Numerizer, 'chronic/numerizer'
+  autoload :Season, 'chronic/season'
+  
+  autoload :Repeater, 'chronic/repeater'
+  autoload :RepeaterYear, 'chronic/repeaters/repeater_year'
+  autoload :RepeaterSeason, 'chronic/repeaters/repeater_season'
+  autoload :RepeaterSeasonName, 'chronic/repeaters/repeater_season_name'
+  autoload :RepeaterMonth, 'chronic/repeaters/repeater_month'
+  autoload :RepeaterMonthName, 'chronic/repeaters/repeater_month_name'
+  autoload :RepeaterFortnight, 'chronic/repeaters/repeater_fortnight'
+  autoload :RepeaterWeek, 'chronic/repeaters/repeater_week'
+  autoload :RepeaterWeekend, 'chronic/repeaters/repeater_weekend'
+  autoload :RepeaterWeekday, 'chronic/repeaters/repeater_weekday'
+  autoload :RepeaterDay, 'chronic/repeaters/repeater_day'
+  autoload :RepeaterDayName, 'chronic/repeaters/repeater_day_name'
+  autoload :RepeaterDayPortion, 'chronic/repeaters/repeater_day_portion'
+  autoload :RepeaterHour, 'chronic/repeaters/repeater_hour'
+  autoload :RepeaterMinute, 'chronic/repeaters/repeater_minute'
+  autoload :RepeaterSecond, 'chronic/repeaters/repeater_second'
+  autoload :RepeaterTime, 'chronic/repeaters/repeater_time'
+  
+end
+
+require 'chronic/chronic'
+
+class Time
+  
+  def self.construct(year, month = 1, day = 1, hour = 0, minute = 0, second = 0)
+    warn "Time.construct will be deprecated in version 0.7.0. Please use Chronic.construct instead"
+    Chronic.construct(year, month, day, hour, minute, second)
+  end
+
+  def to_minidate
+    warn "Time.to_minidate will be deprecated in version 0.7.0. Please use Chronic::MiniDate.from_time(time) instead"
+    Chronic::MiniDate.from_time(self)
+  end
+  
+end

data/lib/chronic/chronic.rb

@@ -0,0 +1,346 @@
+module Chronic
+
+  # Returns a Hash of default configuration options.
+  DEFAULT_OPTIONS = {
+    :context => :future,
+    :now => nil,
+    :guess => true,
+    :ambiguous_time_range => 6,
+    :endian_precedence    => [:middle, :little],
+    :ambiguous_year_future_bias => 50
+  }
+  
+  SEC_PER_DAY = 86400
+
+  class << self
+
+    # Parses a string containing a natural language date or time.
+    #
+    # 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.
+    #
+    # text - The String text to parse.
+    # opts - 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.
+    #        :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.
+    #        :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.
+    #
+    # Returns a new Time object, or Chronic::Span if :guess option is false.
+    def parse(text, opts={})
+      puts "THE CHRONIC!!!"
+      
+      options = DEFAULT_OPTIONS.merge opts
+
+      # ensure the specified options are valid
+      (opts.keys - DEFAULT_OPTIONS.keys).each do |key|
+        raise ArgumentError, "#{key} is not a valid option key."
+      end
+
+      unless [:past, :future, :none].include?(options[:context])
+        raise ArgumentError, "Invalid context, :past/:future only"
+      end
+
+      options[:text] = text
+      Chronic.now = options[:now] || Chronic.time_class.now
+
+      # tokenize words
+      tokens = tokenize(text, options)
+      
+      puts "tokens: #{tokens}"  #jlew
+
+      if Chronic.debug
+        puts "+#{'-' * 51}\n| #{tokens}\n+#{'-' * 51}"
+      end
+
+      span = tokens_to_span(tokens, options)
+      
+      puts "span: #{span}"
+
+      if span
+        options[:guess] ? guess(span) : span
+      end
+    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!(/\./, ':')
+      text.gsub!(/['"]/, '')
+      text.gsub!(/,/, ' ')
+      text.gsub!(/\bsecond (of|day|month|hour|minute|second)\b/, '2nd \1')
+      text = Numerizer.numerize(text)
+      text.gsub!(/ \-(\d{4})\b/, ' tzminus\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\b/, '12:00pm')
+      text.gsub!(/\bmidnight\b/, '24:00')
+      text.gsub!(/\bnow\b/, 'this second')
+      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!(/(\d)([ap]m|oclock)\b/, '\1 \2')
+      text.gsub!(/\b(hence|after|from)\b/, 'future')
+      text
+    end
+
+    # Convert number words to numbers (three => 3, fourth => 4th).
+    #
+    # text - The String to convert.
+    #
+    # Returns a new String with words converted to numbers.
+    def numericize_numbers(text)
+      warn "Chronic.numericize_numbers will be deprecated in version 0.7.0. Please use Chronic::Numerizer.numerize instead"
+      Numerizer.numerize(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 or a new Date object
+    def guess(span)
+      if span.width > 1
+        if span.width == SEC_PER_DAY
+          (span.begin + (span.width / 2)).to_date
+        else
+          span.begin + (span.width / 2)
+        end
+      else
+        span.begin
+      end
+    end
+
+    # List of Handler definitions. See #parse for a list of options this
+    # method accepts.
+    #
+    # options - An optional Hash of configuration options:
+    #           :endian_precedence -
+    #
+    # 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_or_dash?, :time_zone, :scalar_year], :handle_rdn_rmn_sd_t_tz_sy),
+          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([:scalar_year, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :scalar_day, :repeater_time, :time_zone], :handle_sy_sm_sd_t_tz),
+          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([: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([: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, :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_month, :separator_slash_or_dash, :scalar_day], :handle_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)
+        ]
+      }
+
+      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_day, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :scalar_year, :separator_at?, 'time?'], :handle_sd_sm_sy)
+      ]
+
+      case endian = Array(options[:endian_precedence]).first
+      when :little
+        @definitions[:endian] = endians.reverse
+      when :middle
+        @definitions[:endian] = endians
+      else
+        raise ArgumentError, "Unknown endian option '#{endian}'"
+      end
+
+      @definitions
+    end
+
+    # Construct a new time object determining possible month overflows
+    # and leap years.
+    #
+    # year   - Integer year.
+    # month  - Integer month.
+    # day    - Integer day.
+    # hour   - Integer hour.
+    # minute - Integer minute.
+    # second - Integer second.
+    #
+    # Returns a new Time object constructed from these params.
+    def construct(year, month = 1, day = 1, hour = 0, minute = 0, second = 0)
+      if second >= 60
+        minute += second / 60
+        second = second % 60
+      end
+
+      if minute >= 60
+        hour += minute / 60
+        minute = minute % 60
+      end
+
+      if hour >= 24
+        day += hour / 24
+        hour = hour % 24
+      end
+
+      # determine if there is a day overflow. this is complicated by our crappy calendar
+      # system (non-constant number of days per month)
+      day <= 56 || raise("day must be no more than 56 (makes month resolution easier)")
+      if day > 28
+        # no month ever has fewer than 28 days, so only do this if necessary
+        leap_year_month_days = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+        common_year_month_days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+        days_this_month = Date.leap?(year) ? leap_year_month_days[month - 1] : common_year_month_days[month - 1]
+        if day > days_this_month
+          month += day / days_this_month
+          day = day % days_this_month
+        end
+      end
+
+      if month > 12
+        if month % 12 == 0
+          year += (month - 12) / 12
+          month = 12
+        else
+          year += month / 12
+          month = month % 12
+        end
+      end
+
+      Chronic.time_class.local(year, month, day, hour, minute, second)
+    end
+
+    private
+
+    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|
+        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, 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, 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(SeparatorSlashOrDash) || o.get_tag(SeparatorComma) }
+          return handler.invoke(:arrow, good_tokens, options)
+        end
+      end
+
+      definitions[:narrow].each do |handler|
+        if handler.match(tokens, definitions)
+          return handler.invoke(:narrow, tokens, options)
+        end
+      end
+
+      puts "-none" if Chronic.debug
+      return nil
+    end
+
+  end
+
+  # Internal exception
+  class ChronicPain < Exception
+  end
+end