diff --git a/.gemtest b/.gemtest
deleted file mode 100644
index e69de29b..00000000
diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml
new file mode 100644
index 00000000..707570db
--- /dev/null
+++ b/.github/workflows/test.yaml
@@ -0,0 +1,30 @@
+
+name: test
+
+on: [ push, pull_request ]
+
+jobs:
+
+  test:
+
+    if: " ! (contains(github.event.head_commit.message, 'skip ci') || contains(github.event.head_commit.message, 'ci skip'))"
+
+    name: ${{matrix.ruby}} on ${{matrix.os}}
+
+    strategy:
+      matrix:
+        os: [ ubuntu-latest ]
+        ruby: [ 2.3, 2.4, 2.5, 2.6, 2.7, '3.0', 3.1, 3.2, jruby-9.2, jruby-9.3, truffleruby ]
+        experimental: [ false ]
+      fail-fast: false
+    runs-on: ${{matrix.os}}
+    continue-on-error: ${{matrix.experimental}}
+
+    steps:
+      - uses: actions/checkout@v3
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{matrix.ruby}}
+          bundler-cache: true
+      - run: bundle exec rake
+
diff --git a/.gitignore b/.gitignore
index 2c059691..c956b379 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,8 @@
-pkg
 *.rbc
-rdoc
 .yardoc
-doc
+/.bundle/
+/pkg/
+/coverage/
+/doc/
+/tags/
+Gemfile.lock
diff --git a/.yardopts b/.yardopts
deleted file mode 100644
index 6a5ddf21..00000000
--- a/.yardopts
+++ /dev/null
@@ -1,3 +0,0 @@
--m markdown
---readme README.md
---title "Chronic - Natural language date/time parsing"
diff --git a/Gemfile b/Gemfile
new file mode 100644
index 00000000..b4e2a20b
--- /dev/null
+++ b/Gemfile
@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec
diff --git a/HISTORY.md b/HISTORY.md
index 214afcde..3a5cf1a9 100644
--- a/HISTORY.md
+++ b/HISTORY.md
@@ -1,3 +1,66 @@
+# 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)
+* Properly numerize "twelfth", "twentieth" etc. (#172, James McKinney)
+* Ensure Chronic is compatible with Ruby 2.0.0 (#165, Ravil Bayramgalin)
+
+# 0.9.0 / 2012-12-21
+
+* Implement Chronic::Parser class and create an instance of this class
+  instead of leaving all data in the class level of Chronic
+* Various bug fixes
+* Add support for excel date formats (#149, @jmondo)
+* Added support for time expressions such as '10 till' or 'half
+  past two' (#146, @chicagogrooves)
+* Add support for RepeaterDayName, RepeaterMonthName,
+  Ordinal/ScalarDay and Time (#153, @kareemk)
+
+# 0.8.0 / 2012-09-16
+
+* Support parsing "<ordinal> of this month" (#109)
+* Support parsing ISO 8601 format (#115)
+* Support parsing "on <day>" without a timestamp (#117)
+* Fix time parsing regexp (#125)
+* Support time when parsing dd-mm-yyy <time> (#126)
+* Allow anchor handler to accept any separators (at, on) (#128)
+* Support parsing EXIF date format (#112)
+* Start using minitest for testing
+* Ensure periods are interpreted as colons (#81).
+* Support month/day and day/month parsing (#59).
+* Support day(scalar)-month(name)-year(scalar) (#99).
+* Handle text starting with 'a' or 'an' (#101, @steveburkett).
+* Ensure post medium timestamps are correctly formatted (#89)
+
+# 0.6.7 / 2012-01-31
+
+* Handle day, month names with scalar day and year (Joe Fiorini)
+* Ensure 31st parses correctly with day names (Joe Fiorini)
+
+# 0.6.6 / 2011-11-23
+
+* `Chronic.parse('thur')` no longer returns `nil` (@harold)
+
 # 0.6.5 / 2011-11-04
 
 * Fix bug when parsing ordinal repeaters (#73)
diff --git a/README.md b/README.md
index acfa8ce4..07f7c3c0 100644
--- a/README.md
+++ b/README.md
@@ -1,62 +1,60 @@
 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
 
-## INSTALLATION
-
-### RubyGems
-
-    $ [sudo] gem install chronic
+```
+$ gem install chronic
+```
 
-### GitHub
+## Usage
 
-    $ git clone git://github.com/mojombo/chronic.git
-    $ cd chronic && gem build chronic.gemspec
-    $ gem install chronic-<version>.gem
+```ruby
+require 'chronic'
 
+Time.now   #=> Sun Aug 27 23:18:25 PDT 2006
 
-## USAGE
+Chronic.parse('tomorrow')
+  #=> Mon Aug 28 12:00:00 PDT 2006
 
-You can parse strings containing a natural language date using the
-`Chronic.parse` method.
+Chronic.parse('monday', :context => :past)
+  #=> Mon Aug 21 12:00:00 PDT 2006
 
-    require 'chronic'
+Chronic.parse('this tuesday 5:00')
+  #=> Tue Aug 29 17:00:00 PDT 2006
 
-    Time.now   #=> Sun Aug 27 23:18:25 PDT 2006
+Chronic.parse('this tuesday 5:00', :ambiguous_time_range => :none)
+  #=> Tue Aug 29 05:00:00 PDT 2006
 
-    Chronic.parse('tomorrow')
-      #=> Mon Aug 28 12:00:00 PDT 2006
+Chronic.parse('may 27th', :now => Time.local(2000, 1, 1))
+  #=> Sat May 27 12:00:00 PDT 2000
 
-    Chronic.parse('monday', :context => :past)
-      #=> Mon Aug 21 12:00:00 PDT 2006
+Chronic.parse('may 27th', :guess => false)
+  #=> Sun May 27 00:00:00 PDT 2007..Mon May 28 00:00:00 PDT 2007
 
-    Chronic.parse('this tuesday 5:00')
-      #=> Tue Aug 29 17:00:00 PDT 2006
+Chronic.parse('6/4/2012', :endian_precedence => :little)
+  #=> Fri Apr 06 00:00:00 PDT 2012
 
-    Chronic.parse('this tuesday 5:00', :ambiguous_time_range => :none)
-      #=> Tue Aug 29 05:00:00 PDT 2006
+Chronic.parse('INVALID DATE')
+  #=> nil
+```
 
-    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
+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
+## 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
+#### Simple
 
 * thursday
 * november
@@ -64,12 +62,17 @@ Simple
 * friday 13:00
 * mon 2:35
 * 4pm
+* 10 to 8
+* 10 past 2
+* half past 2
 * 6 in the morning
 * friday 1pm
 * sat 7 in the evening
 * yesterday
 * today
 * tomorrow
+* last week
+* next week
 * this tuesday
 * next month
 * last winter
@@ -83,9 +86,10 @@ Simple
 * afternoon yesterday
 * thursday last week
 
-Complex
+#### Complex
 
 * 3 years ago
+* a year ago
 * 5 months before now
 * 7 hours ago
 * 7 days from now
@@ -101,7 +105,7 @@ Complex
 * 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
@@ -126,15 +130,18 @@ Specific Dates
 * 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
 
 
-## TIME ZONES
+## 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
@@ -142,21 +149,22 @@ 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
-
+```
+>> 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
+## 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.
+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
+## Contribute
 
 If you'd like to hack on Chronic, start by forking the repo on GitHub:
 
@@ -166,9 +174,10 @@ 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 `rake`
-1. Ensure your tests pass in multiple timezones. ie `TZ=utc rake` `TZ=BST rake`
+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. 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
diff --git a/Rakefile b/Rakefile
index dbc13c40..50a32f55 100644
--- a/Rakefile
+++ b/Rakefile
@@ -1,26 +1,48 @@
-require 'date'
+$:.unshift File.expand_path('../lib', __FILE__)
+require 'chronic/version'
 
 def version
-  contents = File.read File.expand_path('../lib/chronic.rb', __FILE__)
-  contents[/VERSION = "([^"]+)"/, 1]
+  Chronic::VERSION
 end
 
-task :test do
+def do_test
+  require 'chronic'
   $:.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
+
+desc 'Run tests'
+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"
+desc 'Open an irb session preloaded with this library'
 task :console do
-  sh "irb -Ilib -rchronic"
+  sh 'irb -Ilib -rchronic'
 end
 
 desc "Release Chronic version #{version}"
@@ -36,11 +58,11 @@ task :release => :build do
   sh "gem push pkg/chronic-#{version}.gem"
 end
 
-desc "Build a gem from the gemspec"
+desc 'Build a gem from the gemspec'
 task :build do
-  sh "mkdir -p pkg"
-  sh "gem build chronic.gemspec"
-  sh "mv chronic-#{version}.gem pkg"
+  FileUtils.mkdir_p 'pkg'
+  sh 'gem build chronic.gemspec'
+  FileUtils.mv("./chronic-#{version}.gem", "pkg")
 end
 
-task :default => :test
\ No newline at end of file
+task :default => :test
diff --git a/chronic.gemspec b/chronic.gemspec
index 84a007b6..8e060010 100644
--- a/chronic.gemspec
+++ b/chronic.gemspec
@@ -1,5 +1,5 @@
 $:.unshift File.expand_path('../lib', __FILE__)
-require 'chronic'
+require 'chronic/version'
 
 Gem::Specification.new do |s|
   s.name = 'chronic'
@@ -8,10 +8,18 @@ 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")
-end
\ No newline at end of file
+  s.files = `git ls-files`.split($/)
+  s.test_files = `git ls-files -- test`.split($/)
+
+  s.add_runtime_dependency 'numerizer', '~> 0.2'
+
+  s.add_development_dependency 'rake', '>= 10'
+  s.add_development_dependency 'simplecov', '~> 0'
+  s.add_development_dependency 'minitest', '~> 5.0'
+  s.add_development_dependency 'activesupport', '>= 4.0'
+end
diff --git a/lib/chronic.rb b/lib/chronic.rb
index 3816d36e..d56641fd 100644
--- a/lib/chronic.rb
+++ b/lib/chronic.rb
@@ -1,9 +1,54 @@
 require 'time'
 require 'date'
+require 'numerizer'
 
-# Parse natural language dates and times into Time or {Chronic::Span} objects
+require 'chronic/version'
+
+require 'chronic/parser'
+require 'chronic/date'
+require 'chronic/time'
+
+require 'chronic/handler'
+require 'chronic/handlers'
+require 'chronic/mini_date'
+require 'chronic/span'
+require 'chronic/token'
+require 'chronic/tokenizer'
+require 'chronic/season'
+
+require 'chronic/tag'
+require 'chronic/tags/grabber'
+require 'chronic/tags/ordinal'
+require 'chronic/tags/pointer'
+require 'chronic/tags/scalar'
+require 'chronic/tags/separator'
+require 'chronic/tags/sign'
+require 'chronic/tags/time_zone'
+
+require 'chronic/tags/repeater'
+require 'chronic/repeaters/repeater_year'
+require 'chronic/repeaters/repeater_quarter'
+require 'chronic/repeaters/repeater_quarter_name'
+require 'chronic/repeaters/repeater_season'
+require 'chronic/repeaters/repeater_season_name'
+require 'chronic/repeaters/repeater_month'
+require 'chronic/repeaters/repeater_month_name'
+require 'chronic/repeaters/repeater_fortnight'
+require 'chronic/repeaters/repeater_week'
+require 'chronic/repeaters/repeater_weekend'
+require 'chronic/repeaters/repeater_weekday'
+require 'chronic/repeaters/repeater_day'
+require 'chronic/repeaters/repeater_day_name'
+require 'chronic/repeaters/repeater_day_portion'
+require 'chronic/repeaters/repeater_hour'
+require 'chronic/repeaters/repeater_minute'
+require 'chronic/repeaters/repeater_second'
+require 'chronic/repeaters/repeater_time'
+
+# Parse natural language dates and times into Time or Chronic::Span objects.
+#
+# Examples:
 #
-# @example
 #   require 'chronic'
 #
 #   Time.now   #=> Sun Aug 27 23:18:25 PDT 2006
@@ -13,29 +58,15 @@
 #
 #   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
-#
-# @author Tom Preston-Werner, Lee Jarvis
 module Chronic
-  VERSION = "0.6.5"
 
   class << self
 
-    # @return [Boolean] true when debug mode is enabled
+    # Returns true when debug mode is enabled.
     attr_accessor :debug
 
-    # @example
+    # Examples:
+    #
     #   require 'chronic'
     #   require 'active_support/time'
     #
@@ -44,68 +75,81 @@ class << self
     #   Chronic.parse('June 15 2006 at 5:54 AM')
     #     # => Thu, 15 Jun 2006 05:45:00 UTC +00:00
     #
-    # @return [Time] The time class Chronic uses internally
+    # Returns The Time class Chronic uses internally.
     attr_accessor :time_class
-
-    # The current Time Chronic is using to base from
-    #
-    # @example
-    #   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
-    #
-    # @return [Time, nil]
-    attr_accessor :now
   end
 
   self.debug = false
-  self.time_class = Time
-end
+  self.time_class = ::Time
 
-require 'chronic/chronic'
-require 'chronic/handler'
-require 'chronic/handlers'
-require 'chronic/mini_date'
-require 'chronic/tag'
-require 'chronic/span'
-require 'chronic/token'
-require 'chronic/grabber'
-require 'chronic/pointer'
-require 'chronic/scalar'
-require 'chronic/ordinal'
-require 'chronic/separator'
-require 'chronic/time_zone'
-require 'chronic/numerizer'
-require 'chronic/season'
-
-require 'chronic/repeater'
-require 'chronic/repeaters/repeater_year'
-require 'chronic/repeaters/repeater_season'
-require 'chronic/repeaters/repeater_season_name'
-require 'chronic/repeaters/repeater_month'
-require 'chronic/repeaters/repeater_month_name'
-require 'chronic/repeaters/repeater_fortnight'
-require 'chronic/repeaters/repeater_week'
-require 'chronic/repeaters/repeater_weekend'
-require 'chronic/repeaters/repeater_weekday'
-require 'chronic/repeaters/repeater_day'
-require 'chronic/repeaters/repeater_day_name'
-require 'chronic/repeaters/repeater_day_portion'
-require 'chronic/repeaters/repeater_hour'
-require 'chronic/repeaters/repeater_minute'
-require 'chronic/repeaters/repeater_second'
-require 'chronic/repeaters/repeater_time'
 
-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)
+  # 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 passed to Parser::new.
+  def self.parse(text, options = {})
+    Parser.new(options).parse(text)
   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)
+  # 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 self.construct(year, month = 1, day = 1, hour = 0, minute = 0, second = 0, offset = nil)
+    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
+      days_this_month = ::Date.leap?(year) ? Date::MONTH_DAYS_LEAP[month] : Date::MONTH_DAYS[month]
+      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
+    if Chronic.time_class.name == 'Date'
+      Chronic.time_class.new(year, month, day)
+    elsif not Chronic.time_class.respond_to?(:new) or (RUBY_VERSION.to_f < 1.9 and Chronic.time_class.name == 'Time')
+      Chronic.time_class.local(year, month, day, hour, minute, second)
+    else
+      offset = Time::normalize_offset(offset) if Chronic.time_class.name == 'DateTime'
+      Chronic.time_class.new(year, month, day, hour, minute, second, offset)
+    end
   end
+
 end
diff --git a/lib/chronic/chronic.rb b/lib/chronic/chronic.rb
deleted file mode 100644
index 414751d1..00000000
--- a/lib/chronic/chronic.rb
+++ /dev/null
@@ -1,327 +0,0 @@
-module Chronic
-
-  DEFAULT_OPTIONS = {
-    :context => :future,
-    :now => nil,
-    :guess => true,
-    :ambiguous_time_range => 6,
-    :endian_precedence    => [:middle, :little],
-    :ambiguous_year_future_bias => 50
-  }
-
-  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
-    #
-    # @param [String] text The text to parse
-    #
-    # @option opts [Symbol] :context (:future)
-    #   * If your string represents a birthday, you can set `:context` to
-    #     `:past` and if an ambiguous string is given, it will assume it is
-    #     in the past. Specify `:future` or omit to set a future context.
-    #
-    # @option opts [Object] :now (Time.now)
-    #   * By setting `:now` to a Time, all computations will be based off of
-    #     that time instead of `Time.now`. If set to nil, Chronic will use
-    #     `Time.now`
-    #
-    # @option opts [Boolean] :guess (true)
-    #   * 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 `:guess` to `false` and a {Chronic::Span} will
-    #     be returned
-    #
-    # @option opts [Integer] :ambiguous_time_range (6)
-    #   * 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
-    #
-    # @option opts [Array] :endian_precedence ([:middle, :little])
-    #   * 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 altering the
-    #     `:endian_precedence` to `[:little, :middle]`
-    #
-    # @option opts [Integer] :ambiguous_year_future_bias (50)
-    #   * 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
-    #
-    # @return [Time, Chronic::Span, nil]
-    def parse(text, opts={})
-      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)
-
-      if Chronic.debug
-        puts "+#{'-' * 51}\n| #{tokens}\n+#{'-' * 51}"
-      end
-
-      span = tokens_to_span(tokens, options)
-
-      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)
-    #
-    # @example
-    #   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"
-    #
-    # @param [String] text The string to normalize
-    # @return [String] A new string ready for Chronic to parse
-    def pre_normalize(text)
-      text = text.to_s.downcase
-      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)
-    #
-    # @see Numerizer.numerize
-    # @param [String] text The string to convert
-    # @return [String] 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
-    #
-    # @param [Span] span
-    # @return [Time]
-    def guess(span)
-      if span.width > 1
-        span.begin + (span.width / 2)
-      else
-        span.begin
-      end
-    end
-
-    # List of {Handler} definitions. See {parse} for a list of options this
-    # method accepts
-    #
-    # @see parse
-    # @return [Hash] 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, :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_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 time Object
-    #
-    # @return [Time]
-    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
diff --git a/lib/chronic/date.rb b/lib/chronic/date.rb
new file mode 100644
index 00000000..8c646191
--- /dev/null
+++ b/lib/chronic/date.rb
@@ -0,0 +1,81 @@
+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, width = nil)
+      day >= 1 && day <= 31 && (width.nil? || width <= 2)
+    end
+
+    # Checks if given number could be month
+    def self.could_be_month?(month, width = nil)
+      month >= 1 && month <= 12 && (width.nil? || width <= 2)
+    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)
+    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
diff --git a/lib/chronic/definition.rb b/lib/chronic/definition.rb
new file mode 100644
index 00000000..4f001b35
--- /dev/null
+++ b/lib/chronic/definition.rb
@@ -0,0 +1,128 @@
+require 'chronic/handlers'
+
+module Chronic
+  # SpanDefinitions subclasses return definitions constructed by Handler instances (see handler.rb)
+  # SpanDefinitions subclasses follow a <Type> + Definitions naming pattern
+  # Types of Definitions are collected in Dictionaries (see dictionary.rb)
+  class Definitions
+    attr_reader :options
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def definitions
+      raise "definitions are set in subclasses of #{self.class}"
+    end
+  end
+
+  class SpanDefinitions < Definitions
+    include Handlers
+  end
+
+  class TimeDefinitions < SpanDefinitions
+    def definitions
+      [
+        Handler.new([:repeater_time, :repeater_day_portion?], nil)
+      ]
+    end
+  end
+
+  class DateDefinitions < SpanDefinitions
+    def definitions
+      [
+        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([:repeater_quarter_name, :scalar_year], :handle_rqn_sy),
+        Handler.new([:scalar_year, :repeater_quarter_name], :handle_sy_rqn),
+        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),
+      ]
+    end
+  end
+
+  class AnchorDefinitions < SpanDefinitions
+    def definitions
+      [
+        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)
+      ]
+    end
+  end
+
+  class ArrowDefinitions < SpanDefinitions
+    def definitions
+      [
+        Handler.new([:repeater_month_name, :scalar, :repeater, :pointer], :handle_rmn_s_r_p),
+        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)
+      ]
+    end
+  end
+
+  class NarrowDefinitions < SpanDefinitions
+    def definitions
+      [
+        Handler.new([:ordinal, :repeater, :separator_in, :repeater], :handle_o_r_s_r),
+        Handler.new([:ordinal, :repeater, :grabber, :repeater], :handle_o_r_g_r)
+      ]
+    end
+  end
+
+  class EndianDefinitions < SpanDefinitions
+    def definitions
+      prefered_endian
+    end
+
+    def prefered_endian
+      options[:endian_precedence] ||= [:middle, :little]
+
+      definitions = [
+        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),
+        Handler.new([:scalar_day, :repeater_month_name, :scalar_year, :separator_at?, 'time?'], :handle_sd_rmn_sy)
+      ]
+
+      case endian = Array(options[:endian_precedence]).first
+      when :little
+        definitions.reverse
+      when :middle
+        definitions
+      else
+        raise ArgumentError, "Unknown endian option '#{endian}'"
+      end
+    end
+  end
+
+end
diff --git a/lib/chronic/dictionary.rb b/lib/chronic/dictionary.rb
new file mode 100644
index 00000000..18867a02
--- /dev/null
+++ b/lib/chronic/dictionary.rb
@@ -0,0 +1,36 @@
+require 'chronic/definition'
+
+module Chronic
+  # A collection of definitions
+  class Dictionary
+    attr_reader :defined_items, :options
+
+    def initialize(options = {})
+      @options = options
+      @defined_items = []
+    end
+
+    # returns a hash of each word's Definitions
+    def definitions
+      defined_items.each_with_object({}) do |word, defs|
+        word_type = "#{word.capitalize.to_s + 'Definitions'}"
+        defs[word] = Chronic.const_get(word_type).new(options).definitions
+      end
+    end
+  end
+
+  class SpanDictionary < Dictionary
+    # Collection of SpanDefinitions
+    def initialize(options = {})
+      super
+      @defined_items = [:time,:date,:anchor,:arrow,:narrow,:endian]
+    end
+
+    # returns the definitions of a specific subclass of SpanDefinitions
+    # SpanDefinition#definitions returns an Hash of Handler instances
+    # arguments should come in as symbols
+    def [](handler_type=:symbol)
+      definitions[handler_type]
+    end
+  end
+end
diff --git a/lib/chronic/grabber.rb b/lib/chronic/grabber.rb
deleted file mode 100644
index 1a7ab9b8..00000000
--- a/lib/chronic/grabber.rb
+++ /dev/null
@@ -1,31 +0,0 @@
-module Chronic
-  class Grabber < Tag
-
-    # Scan an Array of {Token}s and apply any necessary Grabber 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
-    def self.scan(tokens, options)
-      tokens.each do |token|
-        if t = scan_for_all(token) then token.tag(t); next end
-      end
-    end
-
-    # @param [Token] token
-    # @return [Grabber, nil]
-    def self.scan_for_all(token)
-      scan_for token, self,
-      {
-        /last/ => :last,
-        /this/ => :this,
-        /next/ => :next
-      }
-    end
-
-    def to_s
-      'grabber-' << @type.to_s
-    end
-  end
-end
\ No newline at end of file
diff --git a/lib/chronic/handler.rb b/lib/chronic/handler.rb
index da9a0ed8..200f6087 100644
--- a/lib/chronic/handler.rb
+++ b/lib/chronic/handler.rb
@@ -1,77 +1,84 @@
 module Chronic
   class Handler
 
-    # @return [Array] A list of patterns
     attr_reader :pattern
 
-    # @return [Symbol] The method which handles this list of patterns.
-    #   This method should exist inside the {Handlers} module
     attr_reader :handler_method
 
-    # @param [Array]  pattern A list of patterns to match tokens against
-    # @param [Symbol] handler_method The method to be invoked when patterns
-    #   are matched. This method should exist inside the {Handlers} module
+    # pattern        - An Array of patterns to match tokens against.
+    # handler_method - A Symbol representing the method to be invoked
+    #   when a pattern matches.
     def initialize(pattern, handler_method)
       @pattern = pattern
       @handler_method = handler_method
     end
 
-    # @param [Array] tokens
-    # @param [Hash]  definitions
-    # @return [Boolean]
-    # @see Chronic.tokens_to_span
+    # tokens - An Array of tokens to process.
+    # definitions - A Hash of definitions to check against.
+    #
+    # 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 ChronicPain, "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 ChronicPain, "Invalid match type: #{element.class}"
         end
+
       end
 
       return false if token_index != tokens.size
       return true
     end
 
-    def invoke(type, tokens, options)
+    def invoke(type, tokens, parser, options)
       if Chronic.debug
         puts "-#{type}"
         puts "Handler: #{@handler_method}"
       end
 
-      Handlers.send(@handler_method, tokens, options)
+      parser.send(@handler_method, tokens, options)
     end
 
-    # @param [Handler]  The handler to compare
-    # @return [Boolean] True if these handlers match
+    # other - The other Handler object to compare.
+    #
+    # Returns true if these Handlers match.
     def ==(other)
       @pattern == other.pattern
     end
@@ -87,4 +94,4 @@ def tags_match?(name, tokens, token_index)
     end
 
   end
-end
\ No newline at end of file
+end
diff --git a/lib/chronic/handlers.rb b/lib/chronic/handlers.rb
index e19cb947..27795a7d 100644
--- a/lib/chronic/handlers.rb
+++ b/lib/chronic/handlers.rb
@@ -4,10 +4,11 @@ module Handlers
 
     # Handle month/day
     def handle_m_d(month, day, time_tokens, options)
-      month.start = Chronic.now
+      month.start = self.now
       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
@@ -17,7 +18,7 @@ def handle_rmn_sd(tokens, options)
       month = tokens[0].get_tag(RepeaterMonthName)
       day = tokens[1].get_tag(ScalarDay).type
 
-      return if month_overflow?(Chronic.now.year, month.index, day)
+      return if month_overflow?(self.now.year, month.index, day)
 
       handle_m_d(month, day, tokens[2..tokens.size], options)
     end
@@ -34,7 +35,7 @@ def handle_rmn_sd_on(tokens, options)
         token_range = 0..0
       end
 
-      return if month_overflow?(Chronic.now.year, month.index, day)
+      return if month_overflow?(self.now.year, month.index, day)
 
       handle_m_d(month, day, tokens[token_range], options)
     end
@@ -44,17 +45,24 @@ def handle_rmn_od(tokens, options)
       month = tokens[0].get_tag(RepeaterMonthName)
       day = tokens[1].get_tag(OrdinalDay).type
 
-      return if month_overflow?(Chronic.now.year, month.index, day)
+      return if month_overflow?(self.now.year, month.index, day)
 
       handle_m_d(month, day, tokens[2..tokens.size], options)
     end
 
+    # Handle ordinal this month
+    def handle_od_rm(tokens, options)
+      day = tokens[0].get_tag(OrdinalDay).type
+      month = tokens[2].get_tag(RepeaterMonth)
+      handle_m_d(month, day, tokens[3..tokens.size], options)
+    end
+
     # Handle ordinal-day/repeater-month-name
     def handle_od_rmn(tokens, options)
       month = tokens[1].get_tag(RepeaterMonthName)
       day = tokens[0].get_tag(OrdinalDay).type
 
-      return if month_overflow?(Chronic.now.year, month.index, day)
+      return if month_overflow?(self.now.year, month.index, day)
 
       handle_m_d(month, day, tokens[2..tokens.size], options)
     end
@@ -80,7 +88,7 @@ def handle_sd_rmn(tokens, options)
       month = tokens[1].get_tag(RepeaterMonthName)
       day = tokens[0].get_tag(ScalarDay).type
 
-      return if month_overflow?(Chronic.now.year, month.index, day)
+      return if month_overflow?(self.now.year, month.index, day)
 
       handle_m_d(month, day, tokens[2..tokens.size], options)
     end
@@ -97,11 +105,24 @@ def handle_rmn_od_on(tokens, options)
         token_range = 0..0
       end
 
-      return if month_overflow?(Chronic.now.year, month.index, day)
+      return if month_overflow?(self.now.year, month.index, day)
 
       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
@@ -124,15 +145,11 @@ def handle_rmn_sy(tokens, options)
     end
 
     # Handle generic timestamp (ruby 1.8)
-    def handle_rdn_rmn_sd_t_tz_sy(tokens, options)
-      t = Chronic.time_class.parse(options[:text])
-      Span.new(t, t + 1)
-    end
-
-    # Handle generic timestamp (ruby 1.9)
-    def handle_sy_sm_sd_t_tz(tokens, options)
+    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
@@ -224,11 +241,38 @@ def handle_sy_sm_sd(tokens, options)
       handle_sm_sd_sy(new_tokens + time_tokens, options)
     end
 
-    # Handle scalar-month/scalar-year
-    def handle_sm_sy(tokens, options)
+    # Handle scalar-month/scalar-day
+    def handle_sm_sd(tokens, options)
       month = tokens[0].get_tag(ScalarMonth).type
-      year = tokens[1].get_tag(ScalarYear).type
+      day = tokens[1].get_tag(ScalarDay).type
+      year = self.now.year
+      time_tokens = tokens.last(tokens.size - 2)
 
+      return if month_overflow?(year, month, day)
+
+      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_or_time(day_start, time_tokens, options)
+      rescue ArgumentError
+        nil
+      end
+    end
+
+    # Handle scalar-day/scalar-month
+    def handle_sd_sm(tokens, options)
+      new_tokens = [tokens[1], tokens[0]]
+      time_tokens = tokens.last(tokens.size - 2)
+      handle_sm_sd(new_tokens + time_tokens, options)
+    end
+
+    def handle_year_and_month(year, month)
       if month == 12
         next_month_year = year + 1
         next_month_month = 1
@@ -245,40 +289,143 @@ def handle_sm_sy(tokens, options)
       end
     end
 
+    # Handle scalar-month/scalar-year
+    def handle_sm_sy(tokens, options)
+      month = tokens[0].get_tag(ScalarMonth).type
+      year = tokens[1].get_tag(ScalarYear).type
+      handle_year_and_month(year, month)
+    end
+
+    # Handle scalar-year/scalar-month
+    def handle_sy_sm(tokens, options)
+      year = tokens[0].get_tag(ScalarYear).type
+      month = tokens[1].get_tag(ScalarMonth).type
+      handle_year_and_month(year, month)
+    end
+
     # Handle RepeaterDayName RepeaterMonthName OrdinalDay
     def handle_rdn_rmn_od(tokens, options)
       month = tokens[1].get_tag(RepeaterMonthName)
       day = tokens[2].get_tag(OrdinalDay).type
-      year = Chronic.now.year
+      time_tokens = tokens.last(tokens.size - 3)
+      year = self.now.year
+
+      return if month_overflow?(year, month.index, day)
+
+      begin
+        if time_tokens.empty?
+          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)
+        else
+          day_start = Chronic.time_class.local(year, month.index, day)
+          day_or_time(day_start, time_tokens, options)
+        end
+      rescue ArgumentError
+        nil
+      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 = Chronic.time_class.local(year, month.index, day + 1)
+        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
+      time_tokens = tokens.last(tokens.size - 2)
+      year = self.now.year
+      month = self.now.month
+      if options[:context] == :future
+        self.now.day > day ? month += 1 : month
+      end
+
+      return if month_overflow?(year, month, day)
+
+      begin
+        if time_tokens.empty?
+          start_time = Chronic.time_class.local(year, month, day)
+          end_time = time_with_rollover(year, month, day + 1)
+          Span.new(start_time, end_time)
+        else
+          day_start = Chronic.time_class.local(year, month, day)
+          day_or_time(day_start, time_tokens, options)
+        end
+      rescue ArgumentError
+        nil
+      end
+    end
+
     # Handle RepeaterDayName RepeaterMonthName ScalarDay
     def handle_rdn_rmn_sd(tokens, options)
       month = tokens[1].get_tag(RepeaterMonthName)
       day = tokens[2].get_tag(ScalarDay).type
-      year = Chronic.now.year
+      time_tokens = tokens.last(tokens.size - 3)
+      year = self.now.year
+
+      return if month_overflow?(year, month.index, day)
+
+      begin
+        if time_tokens.empty?
+          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)
+        else
+          day_start = Chronic.time_class.local(year, month.index, day)
+          day_or_time(day_start, time_tokens, options)
+        end
+      rescue ArgumentError
+        nil
+      end
+    end
+
+    # Handle RepeaterDayName RepeaterMonthName ScalarDay ScalarYear
+    def handle_rdn_rmn_sd_sy(tokens, options)
+      month = tokens[1].get_tag(RepeaterMonthName)
+      day = tokens[2].get_tag(ScalarDay).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 = Chronic.time_class.local(year, month.index, day + 1)
+        end_time = time_with_rollover(year, month.index, day + 1)
         Span.new(start_time, end_time)
       rescue ArgumentError
         nil
       end
     end
 
+    def handle_sm_rmn_sy(tokens, options)
+      day = tokens[0].get_tag(ScalarDay).type
+      month = tokens[1].get_tag(RepeaterMonthName).index
+      year = tokens[2].get_tag(ScalarYear).type
+      if tokens.size > 3
+        time = get_anchor([tokens.last], options).begin
+        h, m, s = time.hour, time.min, time.sec
+        time = Chronic.time_class.local(year, month, day, h, m, s)
+        end_time = Chronic.time_class.local(year, month, day + 1, h, m, s)
+      else
+        time = Chronic.time_class.local(year, month, day)
+        day += 1 unless day >= 31
+        end_time = Chronic.time_class.local(year, month, day)
+      end
+      Span.new(time, end_time)
+    end
+
     # anchors
 
     # Handle repeaters
@@ -301,13 +448,12 @@ def handle_srp(tokens, span, options)
       repeater = tokens[1].get_tag(Repeater)
       pointer = tokens[2].get_tag(Pointer).type
 
-      repeater.offset(span, distance, pointer)
+      repeater.offset(span, distance, pointer) if repeater.respond_to?(:offset)
     end
 
     # Handle scalar/repeater/pointer
     def handle_s_r_p(tokens, options)
-      repeater = tokens[1].get_tag(Repeater)
-      span = Span.new(Chronic.now, Chronic.now + 1)
+      span = Span.new(self.now, self.now + 1)
 
       handle_srp(tokens, span, options)
     end
@@ -324,6 +470,18 @@ def handle_s_r_p_a(tokens, options)
       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)
+
+      span = handle_srp(tokens[0..1]+tokens[4..6], anchor_span, options)
+      handle_srp(tokens[2..3]+tokens[4..6], span, options)
+    end
+
     # narrows
 
     # Handle oridinal repeaters
@@ -362,9 +520,9 @@ def handle_o_r_g_r(tokens, options)
     def day_or_time(day_start, time_tokens, options)
       outer_span = Span.new(day_start, day_start + (24 * 60 * 60))
 
-      if !time_tokens.empty?
-        Chronic.now = outer_span.begin
-        get_anchor(dealias_and_disambiguate_times(time_tokens, options), options)
+      unless time_tokens.empty?
+        self.now = outer_span.begin
+        get_anchor(dealias_and_disambiguate_times(time_tokens, options), options.merge(:context => :future))
       else
         outer_span
       end
@@ -373,7 +531,6 @@ def day_or_time(day_start, time_tokens, options)
     def get_anchor(tokens, options)
       grabber = Grabber.new(:this)
       pointer = :future
-
       repeaters = get_repeaters(tokens)
       repeaters.size.times { tokens.pop }
 
@@ -382,7 +539,7 @@ def get_anchor(tokens, options)
       end
 
       head = repeaters.shift
-      head.start = Chronic.now
+      head.start = self.now
 
       case grabber.type
       when :last
@@ -396,7 +553,7 @@ def get_anchor(tokens, options)
       when :next
         outer_span = head.next(:future)
       else
-        raise ChronicPain, "Invalid grabber"
+        raise 'Invalid grabber'
       end
 
       if Chronic.debug
@@ -412,11 +569,13 @@ def get_repeaters(tokens)
     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]
       end
+    rescue ArgumentError
+      false
     end
 
     # Recursively finds repeaters within other repeaters.
@@ -435,6 +594,20 @@ def find_within(tags, span, pointer)
       end
     end
 
+    def time_with_rollover(year, month, day)
+      date_parts =
+        if month_overflow?(year, month, day)
+          if month == 12
+            [year + 1, 1, 1]
+          else
+            [year, month + 1, 1]
+          end
+        else
+          [year, month, day]
+        end
+      Chronic.time_class.local(*date_parts)
+    end
+
     def dealias_and_disambiguate_times(tokens, options)
       # handle aliases of am/pm
       # 5:00 in the morning -> 5:00 am
diff --git a/lib/chronic/mini_date.rb b/lib/chronic/mini_date.rb
index 1a5a2b42..921fc2a0 100644
--- a/lib/chronic/mini_date.rb
+++ b/lib/chronic/mini_date.rb
@@ -8,7 +8,7 @@ def self.from_time(time)
 
     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 @@ def equals?(other)
       @month == other.month and @day == other.day
     end
   end
-end
\ No newline at end of file
+end
diff --git a/lib/chronic/numerizer.rb b/lib/chronic/numerizer.rb
deleted file mode 100644
index 8648f599..00000000
--- a/lib/chronic/numerizer.rb
+++ /dev/null
@@ -1,121 +0,0 @@
-require 'strscan'
-
-module Chronic
-  class Numerizer
-
-    DIRECT_NUMS = [
-      ['eleven', '11'],
-      ['twelve', '12'],
-      ['thirteen', '13'],
-      ['fourteen', '14'],
-      ['fifteen', '15'],
-      ['sixteen', '16'],
-      ['seventeen', '17'],
-      ['eighteen', '18'],
-      ['nineteen', '19'],
-      ['ninteen', '19'], # Common mis-spelling
-      ['zero', '0'],
-      ['one', '1'],
-      ['two', '2'],
-      ['three', '3'],
-      ['four(\W|$)', '4\1'],  # The weird regex is so that it matches four but not fourty
-      ['five', '5'],
-      ['six(\W|$)', '6\1'],
-      ['seven(\W|$)', '7\1'],
-      ['eight(\W|$)', '8\1'],
-      ['nine(\W|$)', '9\1'],
-      ['ten', '10'],
-      ['\ba[\b^$]', '1'] # doesn't make sense for an 'a' at the end to be a 1
-    ]
-
-    ORDINALS = [
-      ['first', '1'],
-      ['third', '3'],
-      ['fourth', '4'],
-      ['fifth', '5'],
-      ['sixth', '6'],
-      ['seventh', '7'],
-      ['eighth', '8'],
-      ['ninth', '9'],
-      ['tenth', '10']
-    ]
-
-    TEN_PREFIXES = [
-      ['twenty', 20],
-      ['thirty', 30],
-      ['forty', 40],
-      ['fourty', 40], # Common mis-spelling
-      ['fifty', 50],
-      ['sixty', 60],
-      ['seventy', 70],
-      ['eighty', 80],
-      ['ninety', 90]
-    ]
-
-    BIG_PREFIXES = [
-      ['hundred', 100],
-      ['thousand', 1000],
-      ['million', 1_000_000],
-      ['billion', 1_000_000_000],
-      ['trillion', 1_000_000_000_000],
-    ]
-
-    def self.numerize(string)
-      string = string.dup
-
-      # preprocess
-      string.gsub!(/ +|([^\d])-([^\d])/, '\1 \2') # will mutilate hyphenated-words but shouldn't matter for date extraction
-      string.gsub!(/a half/, 'haAlf') # take the 'a' out so it doesn't turn into a 1, save the half for the end
-
-      # easy/direct replacements
-
-      DIRECT_NUMS.each do |dn|
-        string.gsub!(/#{dn[0]}/i, '<num>' + dn[1])
-      end
-
-      ORDINALS.each do |on|
-        string.gsub!(/#{on[0]}/i, '<num>' + on[1] + on[0][-2, 2])
-      end
-
-      # ten, twenty, etc.
-
-      TEN_PREFIXES.each do |tp|
-        string.gsub!(/(?:#{tp[0]}) *<num>(\d(?=[^\d]|$))*/i) { '<num>' + (tp[1] + $1.to_i).to_s }
-      end
-
-      TEN_PREFIXES.each do |tp|
-        string.gsub!(/#{tp[0]}/i) { '<num>' + tp[1].to_s }
-      end
-
-      # hundreds, thousands, millions, etc.
-
-      BIG_PREFIXES.each do |bp|
-        string.gsub!(/(?:<num>)?(\d*) *#{bp[0]}/i) { '<num>' + (bp[1] * $1.to_i).to_s}
-        andition(string)
-      end
-
-      # fractional addition
-      # I'm not combining this with the previous block as using float addition complicates the strings
-      # (with extraneous .0's and such )
-      string.gsub!(/(\d+)(?: | and |-)*haAlf/i) { ($1.to_f + 0.5).to_s }
-
-      string.gsub(/<num>/, '')
-    end
-
-    class << self
-      private
-
-      def andition(string)
-        sc = StringScanner.new(string)
-
-        while sc.scan_until(/<num>(\d+)( | and )<num>(\d+)(?=[^\w]|$)/i)
-          if sc[2] =~ /and/ || sc[1].size > sc[3].size
-            string[(sc.pos - sc.matched_size)..(sc.pos-1)] = '<num>' + (sc[1].to_i + sc[3].to_i).to_s
-            sc.reset
-          end
-        end
-      end
-
-    end
-  end
-end
\ No newline at end of file
diff --git a/lib/chronic/ordinal.rb b/lib/chronic/ordinal.rb
deleted file mode 100644
index 3645aa2b..00000000
--- a/lib/chronic/ordinal.rb
+++ /dev/null
@@ -1,44 +0,0 @@
-module Chronic
-  class Ordinal < Tag
-
-    # Scan an Array of {Token}s 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
-    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)
-        end
-      end
-    end
-
-    def to_s
-      'ordinal'
-    end
-  end
-
-  class OrdinalDay < Ordinal #:nodoc:
-    def to_s
-      super << '-day-' << @type.to_s
-    end
-  end
-
-end
diff --git a/lib/chronic/parser.rb b/lib/chronic/parser.rb
new file mode 100644
index 00000000..f0887245
--- /dev/null
+++ b/lib/chronic/parser.rb
@@ -0,0 +1,222 @@
+require 'chronic/dictionary'
+require 'chronic/handlers'
+
+module Chronic
+  class Parser
+    include Handlers
+
+    # Hash of default configuration options.
+    DEFAULT_OPTIONS = {
+      :context => :future,
+      :now => nil,
+      :hours24 => nil,
+      :week_start => :sunday,
+      :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.
+    #        :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
+    #                 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 = {})
+      validate_options!(options)
+      @options = DEFAULT_OPTIONS.merge(options)
+      @now = options[: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{1,2})\.(\d{1,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!(/\./, ':')
+      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 = 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!(/\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 = {})
+      SpanDictionary.new(options).definitions
+    end
+
+    private
+
+
+    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?
+    end
+
+    def tokenize(text, options)
+      text = pre_normalize(text)
+      tokens = Tokenizer::tokenize(text)
+      [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
diff --git a/lib/chronic/pointer.rb b/lib/chronic/pointer.rb
deleted file mode 100644
index 0ae8e223..00000000
--- a/lib/chronic/pointer.rb
+++ /dev/null
@@ -1,30 +0,0 @@
-module Chronic
-  class Pointer < Tag
-
-    # Scan an Array of {Token}s 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
-    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]
-    def self.scan_for_all(token)
-      scan_for token, self,
-      {
-        /\bpast\b/ => :past,
-        /\b(?:future|in)\b/ => :future,
-      }
-    end
-
-    def to_s
-      'pointer-' << @type.to_s
-    end
-  end
-end
diff --git a/lib/chronic/repeater.rb b/lib/chronic/repeater.rb
deleted file mode 100644
index 679f1b00..00000000
--- a/lib/chronic/repeater.rb
+++ /dev/null
@@ -1,135 +0,0 @@
-module Chronic
-  class Repeater < Tag
-
-    # Scan an Array of {Token}s 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
-    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
-      end
-    end
-
-    # @param [Token] token
-    # @return [RepeaterSeasonName, nil]
-    def self.scan_for_season_names(token)
-      scan_for token, RepeaterSeasonName,
-      {
-        /^springs?$/ => :spring,
-        /^summers?$/ => :summer,
-        /^(autumn)|(fall)s?$/ => :autumn,
-        /^winters?$/ => :winter
-      }
-    end
-
-    # @param [Token] token
-    # @return [RepeaterMonthName, nil]
-    def self.scan_for_month_names(token)
-      scan_for token, RepeaterMonthName,
-      {
-        /^jan\.?(uary)?$/ => :january,
-        /^feb\.?(ruary)?$/ => :february,
-        /^mar\.?(ch)?$/ => :march,
-        /^apr\.?(il)?$/ => :april,
-        /^may$/ => :may,
-        /^jun\.?e?$/ => :june,
-        /^jul\.?y?$/ => :july,
-        /^aug\.?(ust)?$/ => :august,
-        /^sep\.?(t\.?|tember)?$/ => :september,
-        /^oct\.?(ober)?$/ => :october,
-        /^nov\.?(ember)?$/ => :november,
-        /^dec\.?(ember)?$/ => :december
-      }
-    end
-
-    # @param [Token] token
-    # @return [RepeaterDayName, nil]
-    def self.scan_for_day_names(token)
-      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,
-        /^fr[iy](day)?$/ => :friday,
-        /^sat(t?[ue]rday)?$/ => :saturday,
-        /^su[nm](day)?$/ => :sunday
-      }
-    end
-
-    # @param [Token] token
-    # @return [RepeaterDayPortion, nil]
-    def self.scan_for_day_portions(token)
-      scan_for token, RepeaterDayPortion,
-      {
-        /^ams?$/ => :am,
-        /^pms?$/ => :pm,
-        /^mornings?$/ => :morning,
-        /^afternoons?$/ => :afternoon,
-        /^evenings?$/ => :evening,
-        /^(night|nite)s?$/ => :night
-      }
-    end
-
-    # @param [Token] token
-    # @return [RepeaterTime, nil]
-    def self.scan_for_times(token)
-      scan_for token, RepeaterTime, /^\d{1,2}(:?\d{2})?([\.:]?\d{2})?$/
-    end
-
-    # @param [Token] token
-    # @return [Repeater] A new instance of a subclass of Repeater
-    def self.scan_for_units(token)
-      {
-        /^years?$/ => :year,
-        /^seasons?$/ => :season,
-        /^months?$/ => :month,
-        /^fortnights?$/ => :fortnight,
-        /^weeks?$/ => :week,
-        /^weekends?$/ => :weekend,
-        /^(week|business)days?$/ => :weekday,
-        /^days?$/ => :day,
-        /^hours?$/ => :hour,
-        /^minutes?$/ => :minute,
-        /^seconds?$/ => :second
-      }.each do |item, symbol|
-        if item =~ token.word
-          klass_name = 'Repeater' + symbol.to_s.capitalize
-          klass = Chronic.const_get(klass_name)
-          return klass.new(symbol)
-        end
-      end
-      return nil
-    end
-
-    def <=>(other)
-      width <=> other.width
-    end
-
-    # returns the width (in seconds or months) of this repeatable.
-    def width
-      raise("Repeater#width must be overridden in subclasses")
-    end
-
-    # returns the next occurance of this repeatable.
-    def next(pointer)
-      raise("Start point must be set before calling #next") unless @now
-    end
-
-    def this(pointer)
-      raise("Start point must be set before calling #this") unless @now
-    end
-
-    def to_s
-      'repeater'
-    end
-  end
-end
\ No newline at end of file
diff --git a/lib/chronic/repeaters/repeater_day.rb b/lib/chronic/repeaters/repeater_day.rb
index bafc547c..8eca8c30 100644
--- a/lib/chronic/repeaters/repeater_day.rb
+++ b/lib/chronic/repeaters/repeater_day.rb
@@ -2,14 +2,15 @@ module Chronic
   class RepeaterDay < Repeater #:nodoc:
     DAY_SECONDS = 86_400 # (24 * 60 * 60)
 
-    def initialize(type)
+    def initialize(type, width = nil, options = {})
       super
+      @current_day_start = nil
     end
 
     def next(pointer)
       super
 
-      if !@current_day_start
+      unless @current_day_start
         @current_day_start = Chronic.time_class.local(@now.year, @now.month, @now.day)
       end
 
@@ -50,4 +51,4 @@ def to_s
       super << '-day'
     end
   end
-end
\ No newline at end of file
+end
diff --git a/lib/chronic/repeaters/repeater_day_name.rb b/lib/chronic/repeaters/repeater_day_name.rb
index b5afb970..1f3cb554 100644
--- a/lib/chronic/repeaters/repeater_day_name.rb
+++ b/lib/chronic/repeaters/repeater_day_name.rb
@@ -2,8 +2,9 @@ module Chronic
   class RepeaterDayName < Repeater #:nodoc:
     DAY_SECONDS = 86400 # (24 * 60 * 60)
 
-    def initialize(type)
+    def initialize(type, width = nil, options = {})
       super
+      @current_date = nil
     end
 
     def next(pointer)
@@ -11,8 +12,8 @@ def next(pointer)
 
       direction = pointer == :future ? 1 : -1
 
-      if !@current_date
-        @current_date = Date.new(@now.year, @now.month, @now.day)
+      unless @current_date
+        @current_date = ::Date.new(@now.year, @now.month, @now.day)
         @current_date += direction
 
         day_num = symbol_to_number(@type)
@@ -46,7 +47,7 @@ def to_s
 
     def symbol_to_number(sym)
       lookup = {:sunday => 0, :monday => 1, :tuesday => 2, :wednesday => 3, :thursday => 4, :friday => 5, :saturday => 6}
-      lookup[sym] || raise("Invalid symbol specified")
+      lookup[sym] || raise('Invalid symbol specified')
     end
   end
-end
\ No newline at end of file
+end
diff --git a/lib/chronic/repeaters/repeater_day_portion.rb b/lib/chronic/repeaters/repeater_day_portion.rb
index 536e43b5..49384a60 100644
--- a/lib/chronic/repeaters/repeater_day_portion.rb
+++ b/lib/chronic/repeaters/repeater_day_portion.rb
@@ -9,8 +9,9 @@ class RepeaterDayPortion < Repeater #:nodoc:
       :night => (20 * 60 * 60)..(24 * 60 * 60),     # 8pm-12pm
     }
 
-    def initialize(type)
+    def initialize(type, width = nil, options = {})
       super
+      @current_span = nil
 
       if type.kind_of? Integer
         @range = (@type * 60 * 60)..((@type + 12) * 60 * 60)
@@ -19,47 +20,51 @@ def initialize(type)
         @range || raise("Invalid type '#{type}' for RepeaterDayPortion")
       end
 
-      @range || raise("Range should have been set by now")
+      @range || raise('Range should have been set by now')
     end
 
     def next(pointer)
       super
 
-      full_day = 60 * 60 * 24
-
-      if !@current_span
+      unless @current_span
         now_seconds = @now - Chronic.construct(@now.year, @now.month, @now.day)
         if now_seconds < @range.begin
           case pointer
           when :future
             range_start = Chronic.construct(@now.year, @now.month, @now.day) + @range.begin
           when :past
-            range_start = Chronic.construct(@now.year, @now.month, @now.day) - full_day + @range.begin
+            range_start = Chronic.construct(@now.year, @now.month, @now.day - 1) + @range.begin
           end
         elsif now_seconds > @range.end
           case pointer
           when :future
-            range_start = Chronic.construct(@now.year, @now.month, @now.day) + full_day + @range.begin
+            range_start = Chronic.construct(@now.year, @now.month, @now.day + 1) + @range.begin
           when :past
             range_start = Chronic.construct(@now.year, @now.month, @now.day) + @range.begin
           end
         else
           case pointer
           when :future
-            range_start = Chronic.construct(@now.year, @now.month, @now.day) + full_day + @range.begin
+            range_start = Chronic.construct(@now.year, @now.month, @now.day + 1) + @range.begin
           when :past
-            range_start = Chronic.construct(@now.year, @now.month, @now.day) - full_day + @range.begin
+            range_start = Chronic.construct(@now.year, @now.month, @now.day - 1) + @range.begin
           end
         end
-
-        @current_span = Span.new(range_start, range_start + (@range.end - @range.begin))
+        offset = (@range.end - @range.begin)
+        range_end = construct_date_from_reference_and_offset(range_start, offset)
+        @current_span = Span.new(range_start, range_end)
       else
+        days_to_shift_window =
         case pointer
         when :future
-          @current_span += full_day
+          1
         when :past
-          @current_span -= full_day
+          -1
         end
+
+        new_begin = Chronic.construct(@current_span.begin.year, @current_span.begin.month, @current_span.begin.day + days_to_shift_window, @current_span.begin.hour, @current_span.begin.min, @current_span.begin.sec)
+        new_end = Chronic.construct(@current_span.end.year, @current_span.end.month, @current_span.end.day + days_to_shift_window, @current_span.end.hour, @current_span.end.min, @current_span.end.sec)
+        @current_span = Span.new(new_begin, new_end)
       end
     end
 
@@ -67,7 +72,8 @@ def this(context = :future)
       super
 
       range_start = Chronic.construct(@now.year, @now.month, @now.day) + @range.begin
-      @current_span = Span.new(range_start, range_start + (@range.end - @range.begin))
+      range_end = construct_date_from_reference_and_offset(range_start)
+      @current_span = Span.new(range_start, range_end)
     end
 
     def offset(span, amount, pointer)
@@ -78,7 +84,7 @@ def offset(span, amount, pointer)
     end
 
     def width
-      @range || raise("Range has not been set")
+      @range || raise('Range has not been set')
       return @current_span.width if @current_span
       if @type.kind_of? Integer
         return (12 * 60 * 60)
@@ -90,5 +96,14 @@ def width
     def to_s
       super << '-dayportion-' << @type.to_s
     end
+
+    private
+    def construct_date_from_reference_and_offset(reference, offset = nil)
+      elapsed_seconds_for_range = offset || (@range.end - @range.begin)
+      second_hand = ((elapsed_seconds_for_range - (12 * 60))) % 60
+      minute_hand = (elapsed_seconds_for_range - second_hand) / (60) % 60
+      hour_hand = (elapsed_seconds_for_range - minute_hand - second_hand) / (60 * 60) + reference.hour % 24
+      Chronic.construct(reference.year, reference.month, reference.day, hour_hand, minute_hand, second_hand)
+    end
   end
-end
\ No newline at end of file
+end
diff --git a/lib/chronic/repeaters/repeater_fortnight.rb b/lib/chronic/repeaters/repeater_fortnight.rb
index 99bd6feb..908f3a91 100644
--- a/lib/chronic/repeaters/repeater_fortnight.rb
+++ b/lib/chronic/repeaters/repeater_fortnight.rb
@@ -2,14 +2,15 @@ module Chronic
   class RepeaterFortnight < Repeater #:nodoc:
     FORTNIGHT_SECONDS = 1_209_600 # (14 * 24 * 60 * 60)
 
-    def initialize(type)
+    def initialize(type, width = nil, options = {})
       super
+      @current_fortnight_start = nil
     end
 
     def next(pointer)
       super
 
-      if !@current_fortnight_start
+      unless @current_fortnight_start
         case pointer
         when :future
           sunday_repeater = RepeaterDayName.new(:sunday)
@@ -68,4 +69,4 @@ def to_s
       super << '-fortnight'
     end
   end
-end
\ No newline at end of file
+end
diff --git a/lib/chronic/repeaters/repeater_hour.rb b/lib/chronic/repeaters/repeater_hour.rb
index 375b01f8..a3c22bd7 100644
--- a/lib/chronic/repeaters/repeater_hour.rb
+++ b/lib/chronic/repeaters/repeater_hour.rb
@@ -2,14 +2,15 @@ module Chronic
   class RepeaterHour < Repeater #:nodoc:
     HOUR_SECONDS = 3600 # 60 * 60
 
-    def initialize(type)
+    def initialize(type, width = nil, options = {})
       super
+      @current_hour_start = nil
     end
 
     def next(pointer)
       super
 
-      if !@current_hour_start
+      unless @current_hour_start
         case pointer
         when :future
           @current_hour_start = Chronic.construct(@now.year, @now.month, @now.day, @now.hour + 1)
@@ -55,4 +56,4 @@ def to_s
       super << '-hour'
     end
   end
-end
\ No newline at end of file
+end
diff --git a/lib/chronic/repeaters/repeater_minute.rb b/lib/chronic/repeaters/repeater_minute.rb
index 4fac1181..5503a635 100644
--- a/lib/chronic/repeaters/repeater_minute.rb
+++ b/lib/chronic/repeaters/repeater_minute.rb
@@ -2,14 +2,15 @@ module Chronic
   class RepeaterMinute < Repeater #:nodoc:
     MINUTE_SECONDS = 60
 
-    def initialize(type)
+    def initialize(type, width = nil, options = {})
       super
+      @current_minute_start = nil
     end
 
     def next(pointer = :future)
       super
 
-      if !@current_minute_start
+      unless @current_minute_start
         case pointer
         when :future
           @current_minute_start = Chronic.construct(@now.year, @now.month, @now.day, @now.hour, @now.min + 1)
@@ -55,4 +56,4 @@ def to_s
       super << '-minute'
     end
   end
-end
\ No newline at end of file
+end
diff --git a/lib/chronic/repeaters/repeater_month.rb b/lib/chronic/repeaters/repeater_month.rb
index cce192c3..d2c9ab1c 100644
--- a/lib/chronic/repeaters/repeater_month.rb
+++ b/lib/chronic/repeaters/repeater_month.rb
@@ -5,14 +5,15 @@ class RepeaterMonth < Repeater #:nodoc:
     MONTH_DAYS = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
     MONTH_DAYS_LEAP = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
 
-    def initialize(type)
+    def initialize(type, width = nil, options = {})
       super
+      @current_month_start = nil
     end
 
     def next(pointer)
       super
 
-      if !@current_month_start
+      unless @current_month_start
         @current_month_start = offset_by(Chronic.construct(@now.year, @now.month), 1, pointer)
       else
         @current_month_start = offset_by(Chronic.construct(@current_month_start.year, @current_month_start.month), 1, pointer)
@@ -73,7 +74,7 @@ def to_s
     private
 
     def month_days(year, month)
-      Date.leap?(year) ? MONTH_DAYS_LEAP[month - 1] : MONTH_DAYS[month - 1]
+      ::Date.leap?(year) ? MONTH_DAYS_LEAP[month - 1] : MONTH_DAYS[month - 1]
     end
   end
-end
\ No newline at end of file
+end
diff --git a/lib/chronic/repeaters/repeater_month_name.rb b/lib/chronic/repeaters/repeater_month_name.rb
index 6fbf7962..457e0c68 100644
--- a/lib/chronic/repeaters/repeater_month_name.rb
+++ b/lib/chronic/repeaters/repeater_month_name.rb
@@ -16,14 +16,15 @@ class RepeaterMonthName < Repeater #:nodoc:
       :december => 12
     }
 
-    def initialize(type)
+    def initialize(type, width = nil, options = {})
       super
+      @current_month_begin = nil
     end
 
     def next(pointer)
       super
 
-      if !@current_month_begin
+      unless @current_month_begin
         case pointer
         when :future
           if @now.month < index
@@ -44,7 +45,7 @@ def next(pointer)
             @current_month_begin = Chronic.construct(@now.year - 1, index)
           end
         end
-        @current_month_begin || raise("Current month should be set by now")
+        @current_month_begin || raise('Current month should be set by now')
       else
         case pointer
         when :future
@@ -91,4 +92,4 @@ def to_s
       super << '-monthname-' << @type.to_s
     end
   end
-end
\ No newline at end of file
+end
diff --git a/lib/chronic/repeaters/repeater_quarter.rb b/lib/chronic/repeaters/repeater_quarter.rb
new file mode 100644
index 00000000..55fde0c3
--- /dev/null
+++ b/lib/chronic/repeaters/repeater_quarter.rb
@@ -0,0 +1,59 @@
+module Chronic
+  class RepeaterQuarter < Repeater #:nodoc:
+    MONTHS_PER_QUARTER = 3
+    QUARTER_SECONDS = 7_776_000 # 3 * 30 * 24 * 60 * 60
+
+    def next(pointer)
+      @current_span ||= quarter(@now)
+      offset_quarter_amount = pointer == :future ? 1 : -1
+      @current_span = offset_quarter(@current_span.begin, offset_quarter_amount)
+    end
+
+    def this(*)
+      @current_span = quarter(@now)
+    end
+
+    def offset(span, amount, pointer)
+      direction = pointer == :future ? 1 : -1
+      offset_quarter(span.begin, amount * direction)
+    end
+
+    def width
+      @current_span ? @current_span.width : QUARTER_SECONDS
+    end
+
+    def to_s
+      super << '-quarter'
+    end
+
+    protected
+
+    def quarter_index(month)
+      (month - 1) / MONTHS_PER_QUARTER
+    end
+
+    def quarter(time)
+      year, month = time.year, time.month
+
+      quarter_index = quarter_index(month)
+      quarter_month_start = (quarter_index * MONTHS_PER_QUARTER) + 1
+      quarter_month_end = quarter_month_start + MONTHS_PER_QUARTER
+
+      quarter_start = Chronic.construct(year, quarter_month_start)
+      quarter_end = Chronic.construct(year, quarter_month_end)
+
+      Span.new(quarter_start, quarter_end)
+    end
+
+    def offset_quarter(time, amount)
+      new_month = time.month - 1
+      new_month = new_month + MONTHS_PER_QUARTER * amount
+      new_year = time.year + new_month / 12
+      new_month = new_month % 12 + 1
+
+      offset_time_basis = Chronic.construct(new_year, new_month)
+
+      quarter(offset_time_basis)
+    end
+  end
+end
diff --git a/lib/chronic/repeaters/repeater_quarter_name.rb b/lib/chronic/repeaters/repeater_quarter_name.rb
new file mode 100644
index 00000000..872a10c1
--- /dev/null
+++ b/lib/chronic/repeaters/repeater_quarter_name.rb
@@ -0,0 +1,40 @@
+module Chronic
+  class RepeaterQuarterName < RepeaterQuarter #:nodoc:
+    QUARTERS = {
+      :q1 => 0,
+      :q2 => 1,
+      :q3 => 2,
+      :q4 => 3
+    }
+
+    def next(pointer)
+      unless @current_span
+        @current_span = this(pointer)
+      else
+        year_offset = pointer == :future ? 1 : -1
+        new_year = @current_span.begin.year + year_offset
+        time_basis = Chronic.construct(new_year, @current_span.begin.month)
+        @current_span = quarter(time_basis)
+      end
+
+      @current_span
+    end
+
+    def this(pointer = :future)
+      current_quarter_index = quarter_index(@now.month)
+      target_quarter_index = QUARTERS[type]
+
+      year_basis_offset = case pointer
+      when :past then current_quarter_index > target_quarter_index ? 0 : -1
+      when :future then current_quarter_index < target_quarter_index ? 0 : 1
+      else 0
+      end
+
+      year_basis = @now.year + year_basis_offset
+      month_basis = (MONTHS_PER_QUARTER * target_quarter_index) + 1
+      time_basis = Chronic.construct(year_basis, month_basis)
+
+      @current_span = quarter(time_basis)
+    end
+  end
+end
diff --git a/lib/chronic/repeaters/repeater_season.rb b/lib/chronic/repeaters/repeater_season.rb
index e6ceb018..524824e2 100644
--- a/lib/chronic/repeaters/repeater_season.rb
+++ b/lib/chronic/repeaters/repeater_season.rb
@@ -8,8 +8,10 @@ class RepeaterSeason < Repeater #:nodoc:
       :winter => Season.new(MiniDate.new(12,22), MiniDate.new(3,19))
     }
 
-    def initialize(type)
+    def initialize(type, width = nil, options = {})
       super
+      @next_season_start = nil
+      @next_season_end = nil
     end
 
     def next(pointer)
@@ -63,7 +65,7 @@ def to_s
     private
 
     def find_next_season_span(direction, next_season)
-      unless @next_season_start or @next_season_end
+      unless @next_season_start || @next_season_end
         @next_season_start = Chronic.construct(@now.year, @now.month, @now.day)
         @next_season_end = Chronic.construct(@now.year, @now.month, @now.day)
       end
@@ -106,4 +108,4 @@ def construct_season(start, finish)
       )
     end
   end
-end
\ No newline at end of file
+end
diff --git a/lib/chronic/repeaters/repeater_second.rb b/lib/chronic/repeaters/repeater_second.rb
index 6d39b682..ec1c56e4 100644
--- a/lib/chronic/repeaters/repeater_second.rb
+++ b/lib/chronic/repeaters/repeater_second.rb
@@ -2,8 +2,9 @@ module Chronic
   class RepeaterSecond < Repeater #:nodoc:
     SECOND_SECONDS = 1 # haha, awesome
 
-    def initialize(type)
+    def initialize(type, width = nil, options = {})
       super
+      @second_start = nil
     end
 
     def next(pointer = :future)
@@ -11,7 +12,7 @@ def next(pointer = :future)
 
       direction = pointer == :future ? 1 : -1
 
-      if !@second_start
+      unless @second_start
         @second_start = @now + (direction * SECOND_SECONDS)
       else
         @second_start += SECOND_SECONDS * direction
@@ -39,4 +40,4 @@ def to_s
       super << '-second'
     end
   end
-end
\ No newline at end of file
+end
diff --git a/lib/chronic/repeaters/repeater_time.rb b/lib/chronic/repeaters/repeater_time.rb
index 155d80e9..0a496e73 100644
--- a/lib/chronic/repeaters/repeater_time.rb
+++ b/lib/chronic/repeaters/repeater_time.rb
@@ -26,31 +26,41 @@ def to_s
 
     end
 
-    def initialize(time)
-      t = time.gsub(/\:/, '')
-
-      @type =
-      case t.size
-      when 1..2
-        hours = t.to_i
-        Tick.new((hours == 12 ? 0 : hours) * 60 * 60, true)
-      when 3
-        hours = t[0..0].to_i
-        ambiguous = hours > 0
-        Tick.new((hours * 60 * 60) + (t[1..2].to_i * 60), ambiguous)
-      when 4
-        ambiguous = time =~ /:/ && t[0..0].to_i != 0 && t[0..1].to_i <= 12
-        hours = t[0..1].to_i
-        hours == 12 ? Tick.new(0 * 60 * 60 + t[2..3].to_i * 60, ambiguous) : Tick.new(hours * 60 * 60 + t[2..3].to_i * 60, ambiguous)
-      when 5
-        Tick.new(t[0..0].to_i * 60 * 60 + t[1..2].to_i * 60 + t[3..4].to_i, true)
-      when 6
-        ambiguous = time =~ /:/ && t[0..0].to_i != 0 && t[0..1].to_i <= 12
-        hours = t[0..1].to_i
-        hours == 12 ? Tick.new(0 * 60 * 60 + t[2..3].to_i * 60 + t[4..5].to_i, ambiguous) : Tick.new(hours * 60 * 60 + t[2..3].to_i * 60 + t[4..5].to_i, ambiguous)
-      else
-        raise("Time cannot exceed six digits")
+    def initialize(time, width = nil, options = {})
+      @current_time = nil
+      @options = options
+      time_parts = time.split(':')
+      raise ArgumentError, "Time cannot have more than 4 groups of ':'" if time_parts.count > 4
+
+      if time_parts.first.length > 2 and time_parts.count == 1
+        if time_parts.first.length > 4
+          second_index = time_parts.first.length - 2
+          time_parts.insert(1, time_parts.first[second_index..time_parts.first.length])
+          time_parts[0] = time_parts.first[0..second_index - 1]
+        end
+        minute_index = time_parts.first.length - 2
+        time_parts.insert(1, time_parts.first[minute_index..time_parts.first.length])
+        time_parts[0] = time_parts.first[0..minute_index - 1]
+      end
+
+      ambiguous = false
+      hours = time_parts.first.to_i
+
+      if @options[:hours24].nil? or (not @options[:hours24].nil? and @options[:hours24] != true)
+          ambiguous = true if (time_parts.first.length == 1 and hours > 0) or (hours >= 10 and hours <= 12) or (@options[:hours24] == false and hours > 0)
+          hours = 0 if hours == 12 and ambiguous
       end
+
+      hours *= 60 * 60
+      minutes = 0
+      seconds = 0
+      subseconds = 0
+
+      minutes = time_parts[1].to_i * 60 if time_parts.count > 1
+      seconds = time_parts[2].to_i if time_parts.count > 2
+      subseconds = time_parts[3].to_f / (10 ** time_parts[3].length) if time_parts.count > 3
+
+      @type = Tick.new(hours + minutes + seconds + subseconds, ambiguous)
     end
 
     # Return the next past or future Span for the time that this Repeater represents
@@ -98,7 +108,7 @@ def next(pointer)
           end
         end
 
-        @current_time || raise("Current time cannot be nil at this point")
+        @current_time || raise('Current time cannot be nil at this point')
       end
 
       unless first
@@ -125,4 +135,4 @@ def to_s
       super << '-time-' << @type.to_s
     end
   end
-end
\ No newline at end of file
+end
diff --git a/lib/chronic/repeaters/repeater_week.rb b/lib/chronic/repeaters/repeater_week.rb
index f36e7047..c06b96b6 100644
--- a/lib/chronic/repeaters/repeater_week.rb
+++ b/lib/chronic/repeaters/repeater_week.rb
@@ -2,26 +2,28 @@ module Chronic
   class RepeaterWeek < Repeater #:nodoc:
     WEEK_SECONDS = 604800 # (7 * 24 * 60 * 60)
 
-    def initialize(type)
+    def initialize(type, width = nil, options = {})
       super
+      @repeater_day_name = options[:week_start] || :sunday
+      @current_week_start = nil
     end
 
     def next(pointer)
       super
 
-      if !@current_week_start
+      unless @current_week_start
         case pointer
         when :future
-          sunday_repeater = RepeaterDayName.new(:sunday)
-          sunday_repeater.start = @now
-          next_sunday_span = sunday_repeater.next(:future)
-          @current_week_start = next_sunday_span.begin
+          first_week_day_repeater = RepeaterDayName.new(@repeater_day_name)
+          first_week_day_repeater.start = @now
+          next_span = first_week_day_repeater.next(:future)
+          @current_week_start = next_span.begin
         when :past
-          sunday_repeater = RepeaterDayName.new(:sunday)
-          sunday_repeater.start = (@now + RepeaterDay::DAY_SECONDS)
-          sunday_repeater.next(:past)
-          last_sunday_span = sunday_repeater.next(:past)
-          @current_week_start = last_sunday_span.begin
+          first_week_day_repeater = RepeaterDayName.new(@repeater_day_name)
+          first_week_day_repeater.start = (@now + RepeaterDay::DAY_SECONDS)
+          first_week_day_repeater.next(:past)
+          last_span = first_week_day_repeater.next(:past)
+          @current_week_start = last_span.begin
         end
       else
         direction = pointer == :future ? 1 : -1
@@ -37,23 +39,23 @@ def this(pointer = :future)
       case pointer
       when :future
         this_week_start = Chronic.time_class.local(@now.year, @now.month, @now.day, @now.hour) + RepeaterHour::HOUR_SECONDS
-        sunday_repeater = RepeaterDayName.new(:sunday)
-        sunday_repeater.start = @now
-        this_sunday_span = sunday_repeater.this(:future)
-        this_week_end = this_sunday_span.begin
+        first_week_day_repeater = RepeaterDayName.new(@repeater_day_name)
+        first_week_day_repeater.start = @now
+        this_span = first_week_day_repeater.this(:future)
+        this_week_end = this_span.begin
         Span.new(this_week_start, this_week_end)
       when :past
         this_week_end = Chronic.time_class.local(@now.year, @now.month, @now.day, @now.hour)
-        sunday_repeater = RepeaterDayName.new(:sunday)
-        sunday_repeater.start = @now
-        last_sunday_span = sunday_repeater.next(:past)
-        this_week_start = last_sunday_span.begin
+        first_week_day_repeater = RepeaterDayName.new(@repeater_day_name)
+        first_week_day_repeater.start = @now
+        last_span = first_week_day_repeater.next(:past)
+        this_week_start = last_span.begin
         Span.new(this_week_start, this_week_end)
       when :none
-        sunday_repeater = RepeaterDayName.new(:sunday)
-        sunday_repeater.start = @now
-        last_sunday_span = sunday_repeater.next(:past)
-        this_week_start = last_sunday_span.begin
+        first_week_day_repeater = RepeaterDayName.new(@repeater_day_name)
+        first_week_day_repeater.start = @now
+        last_span = first_week_day_repeater.next(:past)
+        this_week_start = last_span.begin
         Span.new(this_week_start, this_week_start + WEEK_SECONDS)
       end
     end
@@ -71,4 +73,4 @@ def to_s
       super << '-week'
     end
   end
-end
\ No newline at end of file
+end
diff --git a/lib/chronic/repeaters/repeater_weekday.rb b/lib/chronic/repeaters/repeater_weekday.rb
index da23fe2f..6c986283 100644
--- a/lib/chronic/repeaters/repeater_weekday.rb
+++ b/lib/chronic/repeaters/repeater_weekday.rb
@@ -11,8 +11,9 @@ class RepeaterWeekday < Repeater #:nodoc:
       :saturday => 6
     }
 
-    def initialize(type)
+    def initialize(type, width = nil, options = {})
       super
+      @current_weekday_start = nil
     end
 
     def next(pointer)
@@ -20,7 +21,7 @@ def next(pointer)
 
       direction = pointer == :future ? 1 : -1
 
-      if !@current_weekday_start
+      unless @current_weekday_start
         @current_weekday_start = Chronic.construct(@now.year, @now.month, @now.day)
         @current_weekday_start += direction * DAY_SECONDS
 
@@ -79,7 +80,7 @@ def is_weekday?(day)
     end
 
     def symbol_to_number(sym)
-      DAYS[sym] || raise("Invalid symbol specified")
+      DAYS[sym] || raise('Invalid symbol specified')
     end
   end
-end
\ No newline at end of file
+end
diff --git a/lib/chronic/repeaters/repeater_weekend.rb b/lib/chronic/repeaters/repeater_weekend.rb
index ecc9f176..3811e03a 100644
--- a/lib/chronic/repeaters/repeater_weekend.rb
+++ b/lib/chronic/repeaters/repeater_weekend.rb
@@ -2,14 +2,15 @@ module Chronic
   class RepeaterWeekend < Repeater #:nodoc:
     WEEKEND_SECONDS = 172_800 # (2 * 24 * 60 * 60)
 
-    def initialize(type)
+    def initialize(type, width = nil, options = {})
       super
+      @current_week_start = nil
     end
 
     def next(pointer)
       super
 
-      if !@current_week_start
+      unless @current_week_start
         case pointer
         when :future
           saturday_repeater = RepeaterDayName.new(:saturday)
@@ -63,4 +64,4 @@ def to_s
       super << '-weekend'
     end
   end
-end
\ No newline at end of file
+end
diff --git a/lib/chronic/repeaters/repeater_year.rb b/lib/chronic/repeaters/repeater_year.rb
index 759a59d2..eb77d709 100644
--- a/lib/chronic/repeaters/repeater_year.rb
+++ b/lib/chronic/repeaters/repeater_year.rb
@@ -2,14 +2,15 @@ module Chronic
   class RepeaterYear < Repeater #:nodoc:
     YEAR_SECONDS =  31536000  # 365 * 24 * 60 * 60
 
-    def initialize(type)
+    def initialize(type, width = nil, options = {})
       super
+      @current_year_start = nil
     end
 
     def next(pointer)
       super
 
-      if !@current_year_start
+      unless @current_year_start
         case pointer
         when :future
           @current_year_start = Chronic.construct(@now.year + 1)
@@ -67,11 +68,11 @@ def build_offset_time(time, amount, direction)
     end
 
     def month_days(year, month)
-      if Date.leap?(year)
+      if ::Date.leap?(year)
         RepeaterMonth::MONTH_DAYS_LEAP[month - 1]
       else
         RepeaterMonth::MONTH_DAYS[month - 1]
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/lib/chronic/scalar.rb b/lib/chronic/scalar.rb
deleted file mode 100644
index 09e3e40a..00000000
--- a/lib/chronic/scalar.rb
+++ /dev/null
@@ -1,109 +0,0 @@
-module Chronic
-  class Scalar < Tag
-    DAY_PORTIONS = %w( am pm morning afternoon evening night )
-
-    # Scan an Array of {Token}s and apply any necessary Scalar 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
-    def self.scan(tokens, options)
-      tokens.each_index do |i|
-        if t = scan_for_scalars(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
-        if t = scan_for_days(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
-        if t = scan_for_months(tokens[i], tokens[i + 1]) then tokens[i].tag(t) end
-        if t = scan_for_years(tokens[i], tokens[i + 1], options) then tokens[i].tag(t) end
-      end
-    end
-
-    # @param [Token] token
-    # @param [Token] post_token
-    # @return [Scalar, nil]
-    def self.scan_for_scalars(token, post_token)
-      if token.word =~ /^\d*$/
-        unless post_token && DAY_PORTIONS.include?(post_token.word)
-          return Scalar.new(token.word.to_i)
-        end
-      end
-    end
-
-    # @param [Token] token
-    # @param [Token] post_token
-    # @return [ScalarDay, nil]
-    def self.scan_for_days(token, post_token)
-      if token.word =~ /^\d\d?$/
-        toi = token.word.to_i
-        unless toi > 31 || toi < 1 || (post_token && DAY_PORTIONS.include?(post_token.word))
-          return ScalarDay.new(toi)
-        end
-      end
-    end
-
-    # @param [Token] token
-    # @param [Token] post_token
-    # @return [ScalarMonth, nil]
-    def self.scan_for_months(token, post_token)
-      if token.word =~ /^\d\d?$/
-        toi = token.word.to_i
-        unless toi > 12 || toi < 1 || (post_token && DAY_PORTIONS.include?(post_token.word))
-          return ScalarMonth.new(toi)
-        end
-      end
-    end
-
-    # @param [Token] token
-    # @param [Token] post_token
-    # @param [Hash] options Options specified in {Chronic.parse}
-    # @return [ScalarYear, nil]
-    def self.scan_for_years(token, post_token, options)
-      if token.word =~ /^([1-9]\d)?\d\d?$/
-        unless post_token && DAY_PORTIONS.include?(post_token.word)
-          year = make_year(token.word.to_i, options[:ambiguous_year_future_bias])
-          return ScalarYear.new(year.to_i)
-        end
-      end
-    end
-
-    # Build a year from a 2 digit suffix
-    #
-    # @example
-    #   make_year(96, 50) #=> 1996
-    #   make_year(79, 20) #=> 2079
-    #   make_year(00, 50) #=> 2000
-    #
-    # @param [Integer] year The two digit year to build from
-    # @param [Integer] bias The amount of future years to bias
-    # @return [Integer] The 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 to_s
-      'scalar'
-    end
-  end
-
-  class ScalarDay < Scalar #:nodoc:
-    def to_s
-      super << '-day-' << @type.to_s
-    end
-  end
-
-  class ScalarMonth < Scalar #:nodoc:
-    def to_s
-      super << '-month-' << @type.to_s
-    end
-  end
-
-  class ScalarYear < Scalar #:nodoc:
-    def to_s
-      super << '-year-' << @type.to_s
-    end
-  end
-end
\ No newline at end of file
diff --git a/lib/chronic/season.rb b/lib/chronic/season.rb
index 478163f0..43937a8b 100644
--- a/lib/chronic/season.rb
+++ b/lib/chronic/season.rb
@@ -1,35 +1,24 @@
 module Chronic
   class Season
-    # @return [MiniDate]
-    attr_reader :start
 
-    # @return [MiniDate]
+    attr_reader :start
     attr_reader :end
 
-    # @param [MiniDate] start_date
-    # @param [MiniDate] end_date
     def initialize(start_date, end_date)
       @start = start_date
       @end = end_date
     end
 
-    # @param [Symbol]  season  The season name
-    # @param [Integer] pointer The direction (-1 for past, 1 for future)
-    # @return [Symbol] The new season name
     def self.find_next_season(season, pointer)
       lookup = [:spring, :summer, :autumn, :winter]
       next_season_num = (lookup.index(season) + 1 * pointer) % 4
       lookup[next_season_num]
     end
 
-    # @param [Symbol] season The season name
-    # @return [Symbol] The new season name
     def self.season_after(season)
       find_next_season(season, +1)
     end
 
-    # @param [Symbol] season The season name
-    # @return [Symbol] The new season name
     def self.season_before(season)
       find_next_season(season, -1)
     end
diff --git a/lib/chronic/separator.rb b/lib/chronic/separator.rb
deleted file mode 100644
index a67f6fae..00000000
--- a/lib/chronic/separator.rb
+++ /dev/null
@@ -1,88 +0,0 @@
-module Chronic
-  class Separator < Tag
-
-    # Scan an Array of {Token}s and apply any necessary Separator 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
-    def self.scan(tokens, options)
-      tokens.each do |token|
-        if t = scan_for_commas(token) then token.tag(t); next end
-        if t = scan_for_slash_or_dash(token) then token.tag(t); next end
-        if t = scan_for_at(token) then token.tag(t); next end
-        if t = scan_for_in(token) then token.tag(t); next end
-        if t = scan_for_on(token) then token.tag(t); next end
-      end
-    end
-
-    # @param [Token] token
-    # @return [SeparatorComma, nil]
-    def self.scan_for_commas(token)
-      scan_for token, SeparatorComma, { /^,$/ => :comma }
-    end
-
-    # @param [Token] token
-    # @return [SeparatorSlashOrDash, nil]
-    def self.scan_for_slash_or_dash(token)
-      scan_for token, SeparatorSlashOrDash,
-      {
-        /^-$/ => :dash,
-        /^\/$/ => :slash
-      }
-    end
-
-    # @param [Token] token
-    # @return [SeparatorAt, nil]
-    def self.scan_for_at(token)
-      scan_for token, SeparatorAt, { /^(at|@)$/ => :at }
-    end
-
-    # @param [Token] token
-    # @return [SeparatorIn, nil]
-    def self.scan_for_in(token)
-      scan_for token, SeparatorIn, { /^in$/ => :in }
-    end
-
-    # @param [Token] token
-    # @return [SeparatorOn, nil]
-    def self.scan_for_on(token)
-      scan_for token, SeparatorOn, { /^on$/ => :on }
-    end
-
-    def to_s
-      'separator'
-    end
-  end
-
-  class SeparatorComma < Separator #:nodoc:
-    def to_s
-      super << '-comma'
-    end
-  end
-
-  class SeparatorSlashOrDash < Separator #:nodoc:
-    def to_s
-      super << '-slashordash-' << @type.to_s
-    end
-  end
-
-  class SeparatorAt < Separator #:nodoc:
-    def to_s
-      super << '-at'
-    end
-  end
-
-  class SeparatorIn < Separator #:nodoc:
-    def to_s
-      super << '-in'
-    end
-  end
-
-  class SeparatorOn < Separator #:nodoc:
-    def to_s
-      super << '-on'
-    end
-  end
-end
\ No newline at end of file
diff --git a/lib/chronic/span.rb b/lib/chronic/span.rb
index 50044ef4..c780dd82 100644
--- a/lib/chronic/span.rb
+++ b/lib/chronic/span.rb
@@ -25,7 +25,7 @@ def to_s
       '(' << self.begin.to_s << '..' << self.end.to_s << ')'
     end
 
-    alias :cover? :include? unless RUBY_VERSION =~ /^1.9/
+    alias :cover? :include? if RUBY_VERSION =~ /^1.8/
 
   end
-end
\ No newline at end of file
+end
diff --git a/lib/chronic/tag.rb b/lib/chronic/tag.rb
index 9dcb3efa..48835410 100644
--- a/lib/chronic/tag.rb
+++ b/lib/chronic/tag.rb
@@ -1,41 +1,88 @@
 module Chronic
   # Tokens are tagged with subclassed instances of this class when
-  # they match specific criteria
+  # they match specific criteria.
   class Tag
 
-    # @return [Symbol]
     attr_accessor :type
+    attr_accessor :width
 
-    # @param [Symbol] type
-    def initialize(type)
+    # type - The Symbol type of this tag.
+    def initialize(type, width = nil, options = {})
       @type = type
+      @width = width
+      @options = options
     end
 
-    # @param [Time] s Set the start timestamp for this Tag
-    def start=(s)
-      @now = s
+    # time - Set the start Time for this Tag.
+    def start=(time)
+      @now = time
     end
 
     class << self
+      # Public: Scan an Array of Token objects.
+      #
+      # tokens  - An Array of tokens to scan.
+      # options - The Hash of options specified in Chronic::parse.
+      #
+      # Returns an Array of tokens.
+      def scan(tokens, options)
+        raise NotImplementedError, 'Subclasses must override scan!'
+      end
+
       private
 
-      # @param [Token] token
-      # @param [Class] klass The class instance to create
-      # @param [Regexp, Hash] items
-      # @return [Object, nil] either a new instance of `klass` or `nil` if
-      #   no match is found
-      def scan_for(token, klass, items={})
-        case items
+      # Internal: Match item and create respective Tag class.
+      #           When item is a Symbol it will match only when it's identical to Token.
+      #           When it's a String it will case-insesitively match partial token,
+      #           but only if item's last char have different type than token text's next char.
+      #           When item is a Regexp it will match by it.
+      #
+      # item    - Item to match. It can be String, Symbol or Regexp.
+      # klass   - Tag class to create.
+      # symbol  - Tag type as symbol or string to pass to Tag class.
+      # token   - Token to match against.
+      # options - Options as hash to pass to Tag class.
+      #
+      # Returns an instance of specified Tag klass or nil if item didn't match.
+      def match_item(item, klass, symbol, token, options)
+        match = false
+        case item
+        when String
+          item_type = Tokenizer.char_type(item.to_s[-1])
+          text_type = token.text[token.position+item.length]
+          text_type = Tokenizer.char_type(text_type) if text_type
+          compatible = true
+          compatible = item_type != text_type if text_type && (item_type == :letter || item_type == :digit)
+          match = compatible && token.text[token.position, item.length].casecmp(item).zero?
+        when Symbol
+          match = token.word == item.to_s
         when Regexp
-          return klass.new(token.word) if items =~ token.word
-        when Hash
+          match = token.word =~ item
+        end
+        return klass.new(symbol, nil, options) if match
+        nil
+      end
+
+      # Internal: Scan for specified items and create respective Tag class.
+      #
+      # token   - Token to match against.
+      # klass   - Tag class to create.
+      # items   - Item(s) to match. It can be Hash, String, Symbol or Regexp.
+      #           Hash keys can be String, Symbol or Regexp, but values much be Symbol.
+      # options - Options as hash to pass to Tag class.
+      #
+      # Returns an instance of specified Tag klass or nil if item(s) didn't match.
+      def scan_for(token, klass, items, options = {})
+        if items.kind_of?(Hash)
           items.each do |item, symbol|
-            return klass.new(symbol) if item =~ token.word
+            scanned = match_item(item, klass, symbol, token, options)
+            return scanned if scanned
           end
+        else
+          return match_item(items, klass, token.word, token, options)
         end
         nil
       end
-
     end
 
   end
diff --git a/lib/chronic/tags/grabber.rb b/lib/chronic/tags/grabber.rb
new file mode 100644
index 00000000..84666570
--- /dev/null
+++ b/lib/chronic/tags/grabber.rb
@@ -0,0 +1,29 @@
+module Chronic
+  class Grabber < Tag
+
+    # Scan an Array of Tokens and apply any necessary Grabber tags to
+    # each token.
+    #
+    # tokens  - An Array of Token objects to scan.
+    # options - The Hash of options specified in Chronic::parse.
+    #
+    # Returns an Array of Token objects.
+    def self.scan(tokens, options)
+      tokens.each do |token|
+        token.tag scan_for(token, self, patterns, options)
+      end
+    end
+
+    def self.patterns
+      @@patterns ||= {
+        'last' => :last,
+        'this' => :this,
+        'next' => :next
+      }
+    end
+
+    def to_s
+      'grabber-' << @type.to_s
+    end
+  end
+end
\ No newline at end of file
diff --git a/lib/chronic/tags/ordinal.rb b/lib/chronic/tags/ordinal.rb
new file mode 100644
index 00000000..33b90a8c
--- /dev/null
+++ b/lib/chronic/tags/ordinal.rb
@@ -0,0 +1,52 @@
+module Chronic
+  class Ordinal < Tag
+
+    # Scan an Array of Token objects and apply any necessary Ordinal
+    # tags to each token.
+    #
+    # 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_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))
+        end
+      end
+    end
+
+    def to_s
+      'ordinal'
+    end
+  end
+
+  class OrdinalDay < Ordinal #:nodoc:
+    def to_s
+      super << '-day-' << @type.to_s
+    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
diff --git a/lib/chronic/tags/pointer.rb b/lib/chronic/tags/pointer.rb
new file mode 100644
index 00000000..a920aaf7
--- /dev/null
+++ b/lib/chronic/tags/pointer.rb
@@ -0,0 +1,28 @@
+module Chronic
+  class Pointer < Tag
+
+    # Scan an Array of Token objects and apply any necessary Pointer
+    # tags to each token.
+    #
+    # 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|
+        token.tag scan_for(token, self, patterns, options)
+      end
+    end
+
+    def self.patterns
+      @@patterns ||= {
+        'past' => :past,
+        /^future|in$/i => :future,
+      }
+    end
+
+    def to_s
+      'pointer-' << @type.to_s
+    end
+  end
+end
diff --git a/lib/chronic/tags/repeater.rb b/lib/chronic/tags/repeater.rb
new file mode 100644
index 00000000..a22b18c3
--- /dev/null
+++ b/lib/chronic/tags/repeater.rb
@@ -0,0 +1,160 @@
+module Chronic
+  class Repeater < Tag
+
+    # Scan an Array of Token objects and apply any necessary Repeater
+    # tags to each token.
+    #
+    # 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|
+        token.tag scan_for_quarter_names(token, options)
+        token.tag scan_for_season_names(token, options)
+        token.tag scan_for_month_names(token, options)
+        token.tag scan_for_day_names(token, options)
+        token.tag scan_for_day_portions(token, options)
+        token.tag scan_for_times(token, options)
+        token.tag scan_for_units(token, options)
+      end
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Repeater object.
+    def self.scan_for_quarter_names(token, options = {})
+      scan_for token, RepeaterQuarterName,
+      {
+        /^q1$/ => :q1,
+        /^q2$/ => :q2,
+        /^q3$/ => :q3,
+        /^q4$/ => :q4
+      }, options
+    end
+
+    # 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
+
+    # 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,
+        /^may$/ => :may,
+        /^jun[:\.]?e?$/ => :june,
+        /^jul[:\.]?y?$/ => :july,
+        /^aug[:\.]?(ust)?$/ => :august,
+        /^sep[:\.]?(t[:\.]?|tember)?$/ => :september,
+        /^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, 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|ur|urs|ers)(day)?$/ => :thursday,
+        /^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, options = {})
+      scan_for token, RepeaterDayPortion,
+      {
+        /^ams?$/ => :am,
+        /^pms?$/ => :pm,
+        /^mornings?$/ => :morning,
+        /^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, 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, options = {})
+      {
+        /^years?$/ => :year,
+        /^q$/ => :quarter,
+        /^seasons?$/ => :season,
+        /^months?$/ => :month,
+        /^fortnights?$/ => :fortnight,
+        /^weeks?$/ => :week,
+        /^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, nil, options)
+        end
+      end
+      return nil
+    end
+
+    def <=>(other)
+      width <=> other.width
+    end
+
+    # returns the width (in seconds or months) of this repeatable.
+    def width
+      raise('Repeater#width must be overridden in subclasses')
+    end
+
+    # returns the next occurance of this repeatable.
+    def next(pointer)
+      raise('Start point must be set before calling #next') unless @now
+    end
+
+    def this(pointer)
+      raise('Start point must be set before calling #this') unless @now
+    end
+
+    def to_s
+      'repeater'
+    end
+  end
+end
diff --git a/lib/chronic/tags/scalar.rb b/lib/chronic/tags/scalar.rb
new file mode 100644
index 00000000..90ce11b9
--- /dev/null
+++ b/lib/chronic/tags/scalar.rb
@@ -0,0 +1,89 @@
+module Chronic
+  class Scalar < Tag
+    DAY_PORTIONS = %w( am pm morning afternoon evening night )
+
+    # Scan an Array of Token objects and apply any necessary Scalar
+    # tags to each token.
+    #
+    # 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_index do |i|
+        token = tokens[i]
+        post_token = tokens[i + 1]
+        if token.word =~ /^\d+$/
+            width = token.word.length
+            scalar = token.word.to_i
+            token.tag(Scalar.new(scalar, width))
+            token.tag(ScalarWide.new(token.word, width)) if width == 4
+            token.tag(ScalarSubsecond.new(scalar, width)) if Chronic::Time::could_be_subsecond?(scalar, width)
+            token.tag(ScalarSecond.new(scalar, width)) if Chronic::Time::could_be_second?(scalar, width)
+            token.tag(ScalarMinute.new(scalar, width)) if Chronic::Time::could_be_minute?(scalar, width)
+            token.tag(ScalarHour.new(scalar, width)) if Chronic::Time::could_be_hour?(scalar, width, options[:hours24] == false)
+            unless post_token and DAY_PORTIONS.include?(post_token.word)
+              token.tag(ScalarDay.new(scalar, width)) if Chronic::Date::could_be_day?(scalar, width)
+              token.tag(ScalarMonth.new(scalar, width)) if Chronic::Date::could_be_month?(scalar, width)
+              if Chronic::Date::could_be_year?(scalar, width)
+                year = Chronic::Date::make_year(scalar, options[:ambiguous_year_future_bias])
+                token.tag(ScalarYear.new(year.to_i, width))
+              end
+          end
+        end
+      end
+    end
+
+    def to_s
+      'scalar'
+    end
+  end
+
+  class ScalarWide < Scalar #:nodoc:
+    def to_s
+      super << '-wide-' << @type.to_s
+    end
+  end
+
+  class ScalarSubsecond < Scalar #:nodoc:
+    def to_s
+      super << '-subsecond-' << @type.to_s
+    end
+  end
+
+  class ScalarSecond < Scalar #:nodoc:
+    def to_s
+      super << '-second-' << @type.to_s
+    end
+  end
+
+  class ScalarMinute < Scalar #:nodoc:
+    def to_s
+      super << '-minute-' << @type.to_s
+    end
+  end
+
+  class ScalarHour < Scalar #:nodoc:
+    def to_s
+      super << '-hour-' << @type.to_s
+    end
+  end
+
+  class ScalarDay < Scalar #:nodoc:
+    def to_s
+      super << '-day-' << @type.to_s
+    end
+  end
+
+  class ScalarMonth < Scalar #:nodoc:
+    def to_s
+      super << '-month-' << @type.to_s
+    end
+  end
+
+  class ScalarYear < Scalar #:nodoc:
+    def to_s
+      super << '-year-' << @type.to_s
+    end
+  end
+end
\ No newline at end of file
diff --git a/lib/chronic/tags/separator.rb b/lib/chronic/tags/separator.rb
new file mode 100644
index 00000000..a8d865dd
--- /dev/null
+++ b/lib/chronic/tags/separator.rb
@@ -0,0 +1,123 @@
+module Chronic
+  class Separator < Tag
+
+    # Scan an Array of Token objects and apply any necessary Separator
+    # tags to each token.
+    #
+    # 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|
+        token.tag scan_for(token, SeparatorComma, { ','.to_sym => :comma })
+        token.tag scan_for(token, SeparatorDot, { '.'.to_sym => :dot })
+        token.tag scan_for(token, SeparatorColon, { ':'.to_sym => :colon })
+        token.tag scan_for(token, SeparatorSpace, { ' '.to_sym => :space })
+        token.tag scan_for(token, SeparatorSlash, { '/'.to_sym => :slash })
+        token.tag scan_for(token, SeparatorDash, { :- => :dash })
+        token.tag scan_for(token, SeparatorAt, { /^(at|@)$/i => :at })
+        token.tag scan_for(token, SeparatorIn, { 'in' => :in })
+        token.tag scan_for(token, SeparatorOn, { 'on' => :on })
+        token.tag scan_for(token, SeparatorAnd, { 'and' => :and })
+        token.tag scan_for(token, SeparatorT, { :T => :T })
+        token.tag scan_for(token, SeparatorW, { :W => :W })
+        token.tag scan_for_quote(token)
+      end
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorQuote object.
+    def self.scan_for_quote(token)
+      scan_for token, SeparatorQuote,
+      {
+        "'".to_sym => :single_quote,
+        '"'.to_sym => :double_quote
+      }
+    end
+
+    def to_s
+      'separator'
+    end
+  end
+
+  class SeparatorComma < Separator #:nodoc:
+    def to_s
+      super << '-comma'
+    end
+  end
+
+  class SeparatorDot < Separator #:nodoc:
+    def to_s
+      super << '-dot'
+    end
+  end
+
+  class SeparatorColon < Separator #:nodoc:
+    def to_s
+      super << '-colon'
+    end
+  end
+
+  class SeparatorSpace < Separator #:nodoc:
+    def to_s
+      super << '-space'
+    end
+  end
+
+  class SeparatorSlash < Separator #:nodoc:
+    def to_s
+      super << '-slash'
+    end
+  end
+
+  class SeparatorDash < Separator #:nodoc:
+    def to_s
+      super << '-dash'
+    end
+  end
+
+  class SeparatorQuote < Separator #:nodoc:
+    def to_s
+      super << '-quote-' << @type.to_s
+    end
+  end
+
+  class SeparatorAt < Separator #:nodoc:
+    def to_s
+      super << '-at'
+    end
+  end
+
+  class SeparatorIn < Separator #:nodoc:
+    def to_s
+      super << '-in'
+    end
+  end
+
+  class SeparatorOn < Separator #:nodoc:
+    def to_s
+      super << '-on'
+    end
+  end
+
+  class SeparatorAnd < Separator #:nodoc:
+    def to_s
+      super << '-and'
+    end
+  end
+
+  class SeparatorT < Separator #:nodoc:
+    def to_s
+      super << '-T'
+    end
+  end
+
+  class SeparatorW < Separator #:nodoc:
+    def to_s
+      super << '-W'
+    end
+  end
+
+end
diff --git a/lib/chronic/tags/sign.rb b/lib/chronic/tags/sign.rb
new file mode 100644
index 00000000..356c67ed
--- /dev/null
+++ b/lib/chronic/tags/sign.rb
@@ -0,0 +1,35 @@
+module Chronic
+  class Sign < Tag
+
+    # Scan an Array of Token objects and apply any necessary Sign
+    # tags to each token.
+    #
+    # 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|
+        token.tag scan_for(token, SignPlus, { :+ => :plus })
+        token.tag scan_for(token, SignMinus, { :- => :minus })
+      end
+    end
+
+    def to_s
+      'sign'
+    end
+  end
+
+  class SignPlus < Sign #:nodoc:
+    def to_s
+      super << '-plus'
+    end
+  end
+
+  class SignMinus < Sign #:nodoc:
+    def to_s
+      super << '-minus'
+    end
+  end
+
+end
diff --git a/lib/chronic/tags/time_zone.rb b/lib/chronic/tags/time_zone.rb
new file mode 100644
index 00000000..26d385ad
--- /dev/null
+++ b/lib/chronic/tags/time_zone.rb
@@ -0,0 +1,32 @@
+module Chronic
+  class TimeZone < Tag
+
+    # Scan an Array of Token objects and apply any necessary TimeZone
+    # tags to each token.
+    #
+    # 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|
+        token.tag scan_for_all(token)
+      end
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new Pointer object.
+    def self.scan_for_all(token)
+      scan_for token, self,
+      {
+        /[PMCE][DS]T|UTC/i => :tz,
+        /(tzminus)?\d{2}:?\d{2}/ => :tz
+      }
+    end
+
+    def to_s
+      'timezone'
+    end
+  end
+end
diff --git a/lib/chronic/time.rb b/lib/chronic/time.rb
new file mode 100644
index 00000000..2b3e6f34
--- /dev/null
+++ b/lib/chronic/time.rb
@@ -0,0 +1,40 @@
+module Chronic
+  class Time
+    HOUR_SECONDS = 3600 # 60 * 60
+    MINUTE_SECONDS = 60
+    SECOND_SECONDS = 1 # haha, awesome
+    SUBSECOND_SECONDS = 0.001
+
+    # Checks if given number could be hour
+    def self.could_be_hour?(hour, width = nil, hours12 = false)
+      hour >= 0 && hour <= (hours12 ? 12 : 24) && (width.nil? || width > 0)
+    end
+
+    # Checks if given number could be minute
+    def self.could_be_minute?(minute, width = nil)
+      minute >= 0 && minute <= 60 && (width.nil? || width <= 2)
+    end
+
+    # Checks if given number could be second
+    def self.could_be_second?(second, width = nil)
+      second >= 0 && second <= 60 && (width.nil? || width <= 2)
+    end
+
+    # Checks if given number could be subsecond
+    def self.could_be_subsecond?(subsecond, width = nil)
+      subsecond >= 0 && subsecond <= 999999 && (width.nil? || width > 0)
+    end
+
+    # normalize offset in seconds to offset as string +mm:ss or -mm:ss
+    def self.normalize_offset(offset)
+      return offset if offset.is_a?(String)
+      offset = Chronic.time_class.now.to_time.utc_offset unless offset # get current system's UTC offset if offset is nil
+      sign = '+'
+      sign = '-' if offset < 0
+      hours = (offset.abs / 3600).to_i.to_s.rjust(2,'0')
+      minutes = (offset.abs % 3600).to_s.rjust(2,'0')
+      sign + hours + minutes
+    end
+
+  end
+end
diff --git a/lib/chronic/time_zone.rb b/lib/chronic/time_zone.rb
deleted file mode 100644
index 5624dfcd..00000000
--- a/lib/chronic/time_zone.rb
+++ /dev/null
@@ -1,30 +0,0 @@
-module Chronic
-  class TimeZone < Tag
-
-    # Scan an Array of {Token}s and apply any necessary TimeZone 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
-    def self.scan(tokens, options)
-      tokens.each do |token|
-        if t = scan_for_all(token) then token.tag(t); next end
-      end
-    end
-
-    # @param [Token] token
-    # @return [TimeZone, nil]
-    def self.scan_for_all(token)
-      scan_for token, self,
-      {
-        /[PMCE][DS]T|UTC/i => :tz,
-        /(tzminus)?\d{2}:?\d{2}/ => :tz
-      }
-    end
-
-    def to_s
-      'timezone'
-    end
-  end
-end
diff --git a/lib/chronic/token.rb b/lib/chronic/token.rb
index 6faac34e..1c9cba1b 100644
--- a/lib/chronic/token.rb
+++ b/lib/chronic/token.rb
@@ -1,45 +1,61 @@
 module Chronic
   class Token
 
-    # @return [String] The word this Token represents
     attr_accessor :word
-
-    # @return [Array] A list of tag associated with this Token
     attr_accessor :tags
 
-    def initialize(word)
+    attr_reader :text
+    attr_reader :position
+
+    def initialize(word, text = nil, position = 0)
       @word = word
       @tags = []
+      @text = text
+      @position = position
     end
 
-    # Tag this token with the specified tag
+    def ==(token)
+      token.word == @word.downcase
+    end
+
+    # Tag this token with the specified tag.
+    #
+    # new_tag - The new Tag object.
     #
-    # @param [Tag] new_tag An instance of {Tag} or one of its subclasses
+    # Returns nothing.
     def tag(new_tag)
-      @tags << new_tag
+      @tags << new_tag if new_tag
     end
 
-    # Remove all tags of the given class
+    # Remove all tags of the given class.
     #
-    # @param [Class] The tag class to remove
+    # tag_class - The tag Class to remove.
+    #
+    # Returns nothing.
     def untag(tag_class)
       @tags.delete_if { |m| m.kind_of? tag_class }
     end
 
-    # @return [Boolean] true if this token has any tags
+    # Returns true if this token has any tags.
     def tagged?
       @tags.size > 0
     end
 
-    # @param [Class] tag_class The tag class to search for
-    # @return [Tag] The first Tag that matches the given class
+    # tag_class - The tag Class to search for.
+    #
+    # Returns The first Tag that matches the given class.
     def get_tag(tag_class)
       @tags.find { |m| m.kind_of? tag_class }
     end
 
     # Print this Token in a pretty way
     def to_s
-      @word << '(' << @tags.join(', ') << ') '
+      @word + '(' + @tags.join(', ') + ') '
+    end
+
+    def inspect
+      to_s
     end
   end
+
 end
\ No newline at end of file
diff --git a/lib/chronic/tokenizer.rb b/lib/chronic/tokenizer.rb
new file mode 100644
index 00000000..a7111bc0
--- /dev/null
+++ b/lib/chronic/tokenizer.rb
@@ -0,0 +1,38 @@
+module Chronic
+  module Tokenizer
+    def self.char_type(char)
+      case char
+      when '.'
+        :period
+      when /[[:alpha:]]/
+        :letter
+      when /[[:digit:]]/
+        :digit
+      when /[[:space:]]/
+        :space
+      when /[[:punct:]]/
+        :punct
+      else
+        :other
+      end
+    end
+
+    # Proccess text to tokens
+    def self.tokenize(text)
+      tokens = []
+      index = 0
+      previos_index = 0
+      text.each_char do |char|
+        type = char_type(char)
+        if type == :space
+          tokens << Token.new(text[previos_index...index], text, previos_index)
+          previos_index = index+1
+        end
+        index += 1
+      end
+      tokens << Token.new(text[previos_index...index], text, previos_index)
+      tokens
+    end
+
+  end
+end
\ No newline at end of file
diff --git a/lib/chronic/version.rb b/lib/chronic/version.rb
new file mode 100644
index 00000000..af461fdc
--- /dev/null
+++ b/lib/chronic/version.rb
@@ -0,0 +1,3 @@
+module Chronic
+  VERSION = '0.10.2'
+end
diff --git a/test/helper.rb b/test/helper.rb
index 30b5c1f2..cb961435 100644
--- a/test/helper.rb
+++ b/test/helper.rb
@@ -3,4 +3,10 @@
   require 'chronic'
 end
 
-require 'test/unit'
\ No newline at end of file
+require 'minitest/autorun'
+
+class TestCase < MiniTest::Test
+  def self.test(name, &block)
+    define_method("test_#{name.gsub(/\W/, '_')}", &block) if block
+  end
+end
diff --git a/test/test_Chronic.rb b/test/test_Chronic.rb
deleted file mode 100644
index d61f3289..00000000
--- a/test/test_Chronic.rb
+++ /dev/null
@@ -1,148 +0,0 @@
-require 'helper'
-
-class TestChronic < Test::Unit::TestCase
-
-  def setup
-    # Wed Aug 16 14:00:00 UTC 2006
-    @now = Time.local(2006, 8, 16, 14, 0, 0, 0)
-  end
-
-  def test_pre_normalize_numerized_string
-    string = 'two and a half years'
-    assert_equal Chronic::Numerizer.numerize(string), Chronic.pre_normalize(string)
-  end
-
-  def test_post_normalize_am_pm_aliases
-    # affect wanted patterns
-
-    tokens = [Chronic::Token.new("5:00"), Chronic::Token.new("morning")]
-    tokens[0].tag(Chronic::RepeaterTime.new("5:00"))
-    tokens[1].tag(Chronic::RepeaterDayPortion.new(:morning))
-
-    assert_equal :morning, tokens[1].tags[0].type
-
-    tokens = Chronic::Handlers.dealias_and_disambiguate_times(tokens, {})
-
-    assert_equal :am, tokens[1].tags[0].type
-    assert_equal 2, tokens.size
-
-    # don't affect unwanted patterns
-
-    tokens = [Chronic::Token.new("friday"), Chronic::Token.new("morning")]
-    tokens[0].tag(Chronic::RepeaterDayName.new(:friday))
-    tokens[1].tag(Chronic::RepeaterDayPortion.new(:morning))
-
-    assert_equal :morning, tokens[1].tags[0].type
-
-    tokens = Chronic::Handlers.dealias_and_disambiguate_times(tokens, {})
-
-    assert_equal :morning, tokens[1].tags[0].type
-    assert_equal 2, tokens.size
-  end
-
-  def test_guess
-    span = Chronic::Span.new(Time.local(2006, 8, 16, 0), Time.local(2006, 8, 17, 0))
-    assert_equal Time.local(2006, 8, 16, 12), Chronic.guess(span)
-
-    span = Chronic::Span.new(Time.local(2006, 8, 16, 0), Time.local(2006, 8, 17, 0, 0, 1))
-    assert_equal Time.local(2006, 8, 16, 12), Chronic.guess(span)
-
-    span = Chronic::Span.new(Time.local(2006, 11), Time.local(2006, 12))
-    assert_equal Time.local(2006, 11, 16), Chronic.guess(span)
-  end
-
-  def test_now
-    Chronic.parse('now', :now => Time.local(2006, 01))
-    assert_equal Time.local(2006, 01), Chronic.now
-
-    Chronic.parse('now', :now => Time.local(2007, 01))
-    assert_equal Time.local(2007, 01), Chronic.now
-  end
-
-  def test_endian_definitions
-    # middle, little
-    endians = [
-      Chronic::Handler.new([:scalar_month, :separator_slash_or_dash, :scalar_day, :separator_slash_or_dash, :scalar_year, :separator_at?, 'time?'], :handle_sm_sd_sy),
-      Chronic::Handler.new([:scalar_day, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :scalar_year, :separator_at?, 'time?'], :handle_sd_sm_sy)
-    ]
-
-    assert_equal endians, Chronic.definitions[:endian]
-
-    defs = Chronic.definitions(:endian_precedence => :little)
-    assert_equal endians.reverse, defs[:endian]
-
-    defs = Chronic.definitions(:endian_precedence => [:little, :middle])
-    assert_equal endians.reverse, defs[:endian]
-
-    assert_raises(ArgumentError) do
-      Chronic.definitions(:endian_precedence => :invalid)
-    end
-  end
-
-  def test_passing_options
-    assert_raises(ArgumentError) do
-      Chronic.parse('now', :invalid => :option)
-    end
-
-    assert_raises(ArgumentError) do
-      Chronic.parse('now', :context => :invalid_context)
-    end
-  end
-
-  def test_debug
-    require 'stringio'
-    $stdout = StringIO.new
-    Chronic.debug = true
-
-    Chronic.parse 'now'
-    assert $stdout.string.include?('this(grabber-this)')
-  ensure
-    $stdout = STDOUT
-    Chronic.debug = false
-  end
-
-  # Chronic.construct
-
-  def test_normal
-    assert_equal Time.local(2006, 1, 2, 0, 0, 0), Chronic.construct(2006, 1, 2, 0, 0, 0)
-    assert_equal Time.local(2006, 1, 2, 3, 0, 0), Chronic.construct(2006, 1, 2, 3, 0, 0)
-    assert_equal Time.local(2006, 1, 2, 3, 4, 0), Chronic.construct(2006, 1, 2, 3, 4, 0)
-    assert_equal Time.local(2006, 1, 2, 3, 4, 5), Chronic.construct(2006, 1, 2, 3, 4, 5)
-  end
-
-  def test_second_overflow
-    assert_equal Time.local(2006, 1, 1, 0, 1, 30), Chronic.construct(2006, 1, 1, 0, 0, 90)
-    assert_equal Time.local(2006, 1, 1, 0, 5, 0), Chronic.construct(2006, 1, 1, 0, 0, 300)
-  end
-
-  def test_minute_overflow
-    assert_equal Time.local(2006, 1, 1, 1, 30), Chronic.construct(2006, 1, 1, 0, 90)
-    assert_equal Time.local(2006, 1, 1, 5), Chronic.construct(2006, 1, 1, 0, 300)
-  end
-
-  def test_hour_overflow
-    assert_equal Time.local(2006, 1, 2, 12), Chronic.construct(2006, 1, 1, 36)
-    assert_equal Time.local(2006, 1, 7), Chronic.construct(2006, 1, 1, 144)
-  end
-
-  def test_day_overflow
-    assert_equal Time.local(2006, 2, 1), Chronic.construct(2006, 1, 32)
-    assert_equal Time.local(2006, 3, 5), Chronic.construct(2006, 2, 33)
-    assert_equal Time.local(2004, 3, 4), Chronic.construct(2004, 2, 33)
-    assert_equal Time.local(2000, 3, 4), Chronic.construct(2000, 2, 33)
-
-    assert_nothing_raised do
-      Chronic.construct(2006, 1, 56)
-    end
-
-    assert_raise(RuntimeError) do
-      Chronic.construct(2006, 1, 57)
-    end
-  end
-
-  def test_month_overflow
-    assert_equal Time.local(2006, 1), Chronic.construct(2005, 13)
-    assert_equal Time.local(2005, 12), Chronic.construct(2000, 72)
-  end
-
-end
diff --git a/test/test_Numerizer.rb b/test/test_Numerizer.rb
deleted file mode 100644
index 9f6b1e99..00000000
--- a/test/test_Numerizer.rb
+++ /dev/null
@@ -1,72 +0,0 @@
-require 'helper'
-
-class ParseNumbersTest < Test::Unit::TestCase
-
-  def test_straight_parsing
-    strings = {
-      'one' => 1,
-      'five' => 5,
-      'ten' => 10,
-      'eleven' => 11,
-      'twelve' => 12,
-      'thirteen' => 13,
-      'fourteen' => 14,
-      'fifteen' => 15,
-      'sixteen' => 16,
-      'seventeen' => 17,
-      'eighteen' => 18,
-      'nineteen' => 19,
-      'twenty' => 20,
-      'twenty seven' => 27,
-      'thirty-one' => 31,
-      'thirty-seven' => 37,
-      'thirty seven' => 37,
-      'fifty nine' => 59,
-      'forty two' => 42,
-      'fourty two' => 42,
-      # 'a hundred' => 100,
-      'one hundred' => 100,
-      'one hundred and fifty' => 150,
-      # 'one fifty' => 150,
-      'two-hundred' => 200,
-      '5 hundred' => 500,
-      'nine hundred and ninety nine' => 999,
-      'one thousand' => 1000,
-      'twelve hundred' => 1200,
-      'one thousand two hundred' => 1_200,
-      'seventeen thousand' => 17_000,
-      'twentyone-thousand-four-hundred-and-seventy-three' => 21_473,
-      'seventy four thousand and two' => 74_002,
-      'ninety nine thousand nine hundred ninety nine' => 99_999,
-      '100 thousand' => 100_000,
-      'two hundred fifty thousand' => 250_000,
-      'one million' => 1_000_000,
-      'one million two hundred fifty thousand and seven' => 1_250_007,
-      'one billion' => 1_000_000_000,
-      'one billion and one' => 1_000_000_001}
-
-    strings.each do |key, val|
-      assert_equal val, Chronic::Numerizer.numerize(key).to_i
-    end
-  end
-
-  def test_ordinal_strings
-    {
-      'first' => '1st',
-      'second' => 'second',
-      'second day' => '2nd day',
-      'second of may' => '2nd of may',
-      'fifth' => '5th',
-      'twenty third' => '23rd',
-      'first day month two' => '1st day month 2'
-    }.each do |key, val|
-      # Use pre_normalize here instead of Numerizer directly because
-      # pre_normalize deals with parsing 'second' appropriately
-      assert_equal val, Chronic.pre_normalize(key)
-    end
-  end
-
-  def test_edges
-    assert_equal "27 Oct 2006 7:30am", Chronic::Numerizer.numerize("27 Oct 2006 7:30am")
-  end
-end
diff --git a/test/test_RepeaterWeek.rb b/test/test_RepeaterWeek.rb
deleted file mode 100644
index b69f0479..00000000
--- a/test/test_RepeaterWeek.rb
+++ /dev/null
@@ -1,62 +0,0 @@
-require 'helper'
-
-class TestRepeaterWeek < Test::Unit::TestCase
-
-  def setup
-    @now = Time.local(2006, 8, 16, 14, 0, 0, 0)
-  end
-
-  def test_next_future
-    weeks = Chronic::RepeaterWeek.new(:week)
-    weeks.start = @now
-
-    next_week = weeks.next(:future)
-    assert_equal Time.local(2006, 8, 20), next_week.begin
-    assert_equal Time.local(2006, 8, 27), next_week.end
-
-    next_next_week = weeks.next(:future)
-    assert_equal Time.local(2006, 8, 27), next_next_week.begin
-    assert_equal Time.local(2006, 9, 3), next_next_week.end
-  end
-
-  def test_next_past
-    weeks = Chronic::RepeaterWeek.new(:week)
-    weeks.start = @now
-
-    last_week = weeks.next(:past)
-    assert_equal Time.local(2006, 8, 6), last_week.begin
-    assert_equal Time.local(2006, 8, 13), last_week.end
-
-    last_last_week = weeks.next(:past)
-    assert_equal Time.local(2006, 7, 30), last_last_week.begin
-    assert_equal Time.local(2006, 8, 6), last_last_week.end
-  end
-
-  def test_this_future
-    weeks = Chronic::RepeaterWeek.new(:week)
-    weeks.start = @now
-
-    this_week = weeks.this(:future)
-    assert_equal Time.local(2006, 8, 16, 15), this_week.begin
-    assert_equal Time.local(2006, 8, 20), this_week.end
-  end
-
-  def test_this_past
-    weeks = Chronic::RepeaterWeek.new(:week)
-    weeks.start = @now
-
-    this_week = weeks.this(:past)
-    assert_equal Time.local(2006, 8, 13, 0), this_week.begin
-    assert_equal Time.local(2006, 8, 16, 14), this_week.end
-  end
-
-  def test_offset
-    span = Chronic::Span.new(@now, @now + 1)
-
-    offset_span = Chronic::RepeaterWeek.new(:week).offset(span, 3, :future)
-
-    assert_equal Time.local(2006, 9, 6, 14), offset_span.begin
-    assert_equal Time.local(2006, 9, 6, 14, 0, 1), offset_span.end
-  end
-
-end
diff --git a/test/test_chronic.rb b/test/test_chronic.rb
new file mode 100644
index 00000000..eb62ad1e
--- /dev/null
+++ b/test/test_chronic.rb
@@ -0,0 +1,203 @@
+require 'helper'
+
+class TestChronic < TestCase
+
+  def setup
+    # Wed Aug 16 14:00:00 UTC 2006
+    @now = Time.local(2006, 8, 16, 14, 0, 0, 0)
+  end
+
+  def test_pre_normalize
+    assert_equal Chronic::Parser.new.pre_normalize('12:55 pm'), Chronic::Parser.new.pre_normalize('12.55 pm')
+  end
+
+  def test_pre_normalize_numerized_string
+    string = 'two and a half years'
+    assert_equal Numerizer.numerize(string), Chronic::Parser.new.pre_normalize(string)
+  end
+
+  def test_post_normalize_am_pm_aliases
+    # affect wanted patterns
+
+    tokens = [Chronic::Token.new("5:00"), Chronic::Token.new("morning")]
+    tokens[0].tag(Chronic::RepeaterTime.new("5:00"))
+    tokens[1].tag(Chronic::RepeaterDayPortion.new(:morning))
+
+    assert_equal :morning, tokens[1].tags[0].type
+
+    tokens = Chronic::Handlers.dealias_and_disambiguate_times(tokens, {})
+
+    assert_equal :am, tokens[1].tags[0].type
+    assert_equal 2, tokens.size
+
+    # don't affect unwanted patterns
+
+    tokens = [Chronic::Token.new("friday"), Chronic::Token.new("morning")]
+    tokens[0].tag(Chronic::RepeaterDayName.new(:friday))
+    tokens[1].tag(Chronic::RepeaterDayPortion.new(:morning))
+
+    assert_equal :morning, tokens[1].tags[0].type
+
+    tokens = Chronic::Handlers.dealias_and_disambiguate_times(tokens, {})
+
+    assert_equal :morning, tokens[1].tags[0].type
+    assert_equal 2, tokens.size
+  end
+
+  def test_guess
+    span = Chronic::Span.new(Time.local(2006, 8, 16, 0), Time.local(2006, 8, 17, 0))
+    assert_equal Time.local(2006, 8, 16, 12), Chronic::Parser.new.guess(span)
+
+    span = Chronic::Span.new(Time.local(2006, 8, 16, 0), Time.local(2006, 8, 17, 0, 0, 1))
+    assert_equal Time.local(2006, 8, 16, 12), Chronic::Parser.new.guess(span)
+
+    span = Chronic::Span.new(Time.local(2006, 11), Time.local(2006, 12))
+    assert_equal Time.local(2006, 11, 16), Chronic::Parser.new.guess(span)
+  end
+
+  def test_endian_definitions
+    # middle, little
+    endians = [
+      Chronic::Handler.new([:scalar_month, [:separator_slash, :separator_dash], :scalar_day, [:separator_slash, :separator_dash], :scalar_year, :separator_at?, 'time?'], :handle_sm_sd_sy),
+      Chronic::Handler.new([:scalar_month, [:separator_slash, :separator_dash], :scalar_day, :separator_at?, 'time?'], :handle_sm_sd),
+      Chronic::Handler.new([:scalar_day, [:separator_slash, :separator_dash], :scalar_month, :separator_at?, 'time?'], :handle_sd_sm),
+      Chronic::Handler.new([:scalar_day, [:separator_slash, :separator_dash], :scalar_month, [:separator_slash, :separator_dash], :scalar_year, :separator_at?, 'time?'], :handle_sd_sm_sy),
+      Chronic::Handler.new([:scalar_day, :repeater_month_name, :scalar_year, :separator_at?, 'time?'], :handle_sd_rmn_sy)
+    ]
+
+    assert_equal endians, Chronic::SpanDictionary.new.definitions[:endian]
+
+    defs = Chronic::SpanDictionary.new(:endian_precedence => :little).definitions
+    assert_equal endians.reverse, defs[:endian]
+
+    defs = Chronic::SpanDictionary.new(:endian_precedence => [:little, :middle]).definitions
+    assert_equal endians.reverse, defs[:endian]
+
+    assert_raises(ArgumentError) do
+      Chronic::SpanDictionary.new(:endian_precedence => :invalid).definitions
+    end
+  end
+
+  def test_debug
+    require 'stringio'
+    $stdout = StringIO.new
+    Chronic.debug = true
+
+    Chronic.parse 'now'
+    assert $stdout.string.include?('this(grabber-this)')
+  ensure
+    $stdout = STDOUT
+    Chronic.debug = false
+  end
+
+  # Chronic.construct
+
+  def test_normal
+    assert_equal Time.local(2006, 1, 2, 0, 0, 0), Chronic.construct(2006, 1, 2, 0, 0, 0)
+    assert_equal Time.local(2006, 1, 2, 3, 0, 0), Chronic.construct(2006, 1, 2, 3, 0, 0)
+    assert_equal Time.local(2006, 1, 2, 3, 4, 0), Chronic.construct(2006, 1, 2, 3, 4, 0)
+    assert_equal Time.local(2006, 1, 2, 3, 4, 5), Chronic.construct(2006, 1, 2, 3, 4, 5)
+  end
+
+  def test_second_overflow
+    assert_equal Time.local(2006, 1, 1, 0, 1, 30), Chronic.construct(2006, 1, 1, 0, 0, 90)
+    assert_equal Time.local(2006, 1, 1, 0, 5, 0), Chronic.construct(2006, 1, 1, 0, 0, 300)
+  end
+
+  def test_minute_overflow
+    assert_equal Time.local(2006, 1, 1, 1, 30), Chronic.construct(2006, 1, 1, 0, 90)
+    assert_equal Time.local(2006, 1, 1, 5), Chronic.construct(2006, 1, 1, 0, 300)
+  end
+
+  def test_hour_overflow
+    assert_equal Time.local(2006, 1, 2, 12), Chronic.construct(2006, 1, 1, 36)
+    assert_equal Time.local(2006, 1, 7), Chronic.construct(2006, 1, 1, 144)
+  end
+
+  def test_day_overflow
+    assert_equal Time.local(2006, 2, 1), Chronic.construct(2006, 1, 32)
+    assert_equal Time.local(2006, 3, 5), Chronic.construct(2006, 2, 33)
+    assert_equal Time.local(2004, 3, 4), Chronic.construct(2004, 2, 33)
+    assert_equal Time.local(2000, 3, 4), Chronic.construct(2000, 2, 33)
+
+    assert_raises(RuntimeError) do
+      Chronic.construct(2006, 1, 57)
+    end
+  end
+
+  def test_month_overflow
+    assert_equal Time.local(2006, 1), Chronic.construct(2005, 13)
+    assert_equal Time.local(2005, 12), Chronic.construct(2000, 72)
+  end
+
+  def test_time
+    org = Chronic.time_class
+    begin
+      Chronic.time_class = ::Time
+      assert_equal ::Time.new(2013, 8, 27, 20, 30, 40, '+05:30'), Chronic.construct(2013, 8, 27, 20, 30, 40, '+05:30')
+      assert_equal ::Time.new(2013, 8, 27, 20, 30, 40, '-08:00'), Chronic.construct(2013, 8, 27, 20, 30, 40, -28800)
+    ensure
+      Chronic.time_class = org
+    end
+  end
+
+  def test_date
+    org = Chronic.time_class
+    begin
+      Chronic.time_class = ::Date
+      assert_equal Date.new(2013, 8, 27), Chronic.construct(2013, 8, 27)
+    ensure
+      Chronic.time_class = org
+    end
+  end
+
+  def test_datetime
+    org = Chronic.time_class
+    begin
+      Chronic.time_class = ::DateTime
+      assert_equal DateTime.new(2013, 8, 27, 20, 30, 40, '+05:30'), Chronic.construct(2013, 8, 27, 20, 30, 40, '+05:30')
+      assert_equal DateTime.new(2013, 8, 27, 20, 30, 40, '-08:00'), Chronic.construct(2013, 8, 27, 20, 30, 40, -28800)
+    ensure
+      Chronic.time_class = org
+    end
+  end
+
+  def test_valid_options
+    options = {
+      :context => :future,
+      :now => nil,
+      :hours24 => nil,
+      :week_start => :sunday,
+      :guess => true,
+      :ambiguous_time_range => 6,
+      :endian_precedence    => [:middle, :little],
+      :ambiguous_year_future_bias => 50
+    }
+    refute_nil Chronic.parse('now', options)
+  end
+
+  def test_invalid_options
+    assert_raises(ArgumentError) { Chronic.parse('now', foo: 'boo') }
+    assert_raises(ArgumentError) { Chronic.parse('now', time_class: Time) }
+  end
+
+  def test_activesupport
+=begin
+    # ActiveSupport needs MiniTest '~> 4.2' which conflicts with '~> 5.0'
+    require 'active_support/time'
+    org = Chronic.time_class
+    org_zone = ::Time.zone
+    begin
+      ::Time.zone = "Tokyo"
+      Chronic.time_class = ::Time.zone
+      assert_equal Time.new(2013, 8, 27, 20, 30, 40, '+09:00'), Chronic.construct(2013, 8, 27, 20, 30, 40)
+      ::Time.zone = "Indiana (East)"
+      Chronic.time_class = ::Time.zone
+      assert_equal Time.new(2013, 8, 27, 20, 30, 40, -14400), Chronic.construct(2013, 8, 27, 20, 30, 40)
+    ensure
+      Chronic.time_class = org
+      ::Time.zone = org_zone
+    end
+=end
+  end
+end
diff --git a/test/test_DaylightSavings.rb b/test/test_daylight_savings.rb
similarity index 98%
rename from test/test_DaylightSavings.rb
rename to test/test_daylight_savings.rb
index fc58ba97..d6f303fb 100644
--- a/test/test_DaylightSavings.rb
+++ b/test/test_daylight_savings.rb
@@ -1,6 +1,6 @@
 require 'helper'
 
-class TestDaylightSavings < Test::Unit::TestCase
+class TestDaylightSavings < TestCase
 
   def setup
     @begin_daylight_savings = Time.local(2008, 3, 9, 5, 0, 0, 0)
diff --git a/test/test_Handler.rb b/test/test_handler.rb
similarity index 63%
rename from test/test_Handler.rb
rename to test/test_handler.rb
index 22b4a3ba..77e0c7fe 100644
--- a/test/test_Handler.rb
+++ b/test/test_handler.rb
@@ -1,24 +1,28 @@
 require 'helper'
 
-class TestHandler < Test::Unit::TestCase
+class TestHandler < TestCase
 
   def setup
     # Wed Aug 16 14:00:00 UTC 2006
     @now = Time.local(2006, 8, 16, 14, 0, 0, 0)
   end
 
+  def definitions
+    @definitions ||= Chronic::SpanDictionary.new.definitions
+  end
+
   def test_handler_class_1
     handler = Chronic::Handler.new([:repeater], :handler)
 
     tokens = [Chronic::Token.new('friday')]
     tokens[0].tag(Chronic::RepeaterDayName.new(:friday))
 
-    assert handler.match(tokens, Chronic.definitions)
+    assert handler.match(tokens, definitions)
 
     tokens << Chronic::Token.new('afternoon')
     tokens[1].tag(Chronic::RepeaterDayPortion.new(:afternoon))
 
-    assert !handler.match(tokens, Chronic.definitions)
+    assert !handler.match(tokens, definitions)
   end
 
   def test_handler_class_2
@@ -27,17 +31,17 @@ def test_handler_class_2
     tokens = [Chronic::Token.new('friday')]
     tokens[0].tag(Chronic::RepeaterDayName.new(:friday))
 
-    assert handler.match(tokens, Chronic.definitions)
+    assert handler.match(tokens, definitions)
 
     tokens << Chronic::Token.new('afternoon')
     tokens[1].tag(Chronic::RepeaterDayPortion.new(:afternoon))
 
-    assert handler.match(tokens, Chronic.definitions)
+    assert handler.match(tokens, definitions)
 
     tokens << Chronic::Token.new('afternoon')
     tokens[2].tag(Chronic::RepeaterDayPortion.new(:afternoon))
 
-    assert !handler.match(tokens, Chronic.definitions)
+    assert !handler.match(tokens, definitions)
   end
 
   def test_handler_class_3
@@ -46,12 +50,12 @@ def test_handler_class_3
     tokens = [Chronic::Token.new('friday')]
     tokens[0].tag(Chronic::RepeaterDayName.new(:friday))
 
-    assert handler.match(tokens, Chronic.definitions)
+    assert handler.match(tokens, definitions)
 
     tokens << Chronic::Token.new('afternoon')
     tokens[1].tag(Chronic::RepeaterDayPortion.new(:afternoon))
 
-    assert !handler.match(tokens, Chronic.definitions)
+    assert !handler.match(tokens, definitions)
   end
 
   def test_handler_class_4
@@ -60,12 +64,12 @@ def test_handler_class_4
     tokens = [Chronic::Token.new('may')]
     tokens[0].tag(Chronic::RepeaterMonthName.new(:may))
 
-    assert !handler.match(tokens, Chronic.definitions)
+    assert !handler.match(tokens, definitions)
 
     tokens << Chronic::Token.new('27')
     tokens[1].tag(Chronic::ScalarDay.new(27))
 
-    assert handler.match(tokens, Chronic.definitions)
+    assert handler.match(tokens, definitions)
   end
 
   def test_handler_class_5
@@ -74,17 +78,17 @@ def test_handler_class_5
     tokens = [Chronic::Token.new('friday')]
     tokens[0].tag(Chronic::RepeaterDayName.new(:friday))
 
-    assert handler.match(tokens, Chronic.definitions)
+    assert handler.match(tokens, definitions)
 
     tokens << Chronic::Token.new('5:00')
     tokens[1].tag(Chronic::RepeaterTime.new('5:00'))
 
-    assert handler.match(tokens, Chronic.definitions)
+    assert handler.match(tokens, definitions)
 
     tokens << Chronic::Token.new('pm')
     tokens[2].tag(Chronic::RepeaterDayPortion.new(:pm))
 
-    assert handler.match(tokens, Chronic.definitions)
+    assert handler.match(tokens, definitions)
   end
 
   def test_handler_class_6
@@ -98,7 +102,27 @@ def test_handler_class_6
     tokens[1].tag(Chronic::RepeaterYear.new(:year))
     tokens[2].tag(Chronic::Pointer.new(:past))
 
-    assert handler.match(tokens, Chronic.definitions)
+    assert handler.match(tokens, definitions)
+  end
+
+  def test_handler_class_7
+    handler = Chronic::Handler.new([[:separator_on, :separator_at], :scalar], :handler)
+
+    tokens = [Chronic::Token.new('at'),
+              Chronic::Token.new('14')]
+
+    tokens[0].tag(Chronic::SeparatorAt.new('at'))
+    tokens[1].tag(Chronic::Scalar.new(14))
+
+    assert handler.match(tokens, definitions)
+
+    tokens = [Chronic::Token.new('on'),
+              Chronic::Token.new('15')]
+
+    tokens[0].tag(Chronic::SeparatorOn.new('on'))
+    tokens[1].tag(Chronic::Scalar.new(15))
+
+    assert handler.match(tokens, definitions)
   end
 
 end
diff --git a/test/test_MiniDate.rb b/test/test_mini_date.rb
similarity index 82%
rename from test/test_MiniDate.rb
rename to test/test_mini_date.rb
index 0710568f..3ae441d5 100644
--- a/test/test_MiniDate.rb
+++ b/test/test_mini_date.rb
@@ -1,32 +1,32 @@
 require 'helper'
 
-class TestMiniDate < Test::Unit::TestCase
+class TestMiniDate < TestCase
   def test_valid_month
-    assert_raise(ArgumentError){ Chronic::MiniDate.new(0,12) }
-    assert_raise(ArgumentError){ Chronic::MiniDate.new(13,1) }
+    assert_raises(ArgumentError){ Chronic::MiniDate.new(0,12) }
+    assert_raises(ArgumentError){ Chronic::MiniDate.new(13,1) }
   end
-  
+
   def test_is_between
     m=Chronic::MiniDate.new(3,2)
     assert m.is_between?(Chronic::MiniDate.new(2,4), Chronic::MiniDate.new(4,7))
-    assert !m.is_between?(Chronic::MiniDate.new(1,5), Chronic::MiniDate.new(2,7))    
-    
+    assert !m.is_between?(Chronic::MiniDate.new(1,5), Chronic::MiniDate.new(2,7))
+
     #There was a hang if date tested is in december and outside the testing range
     m=Chronic::MiniDate.new(12,24)
     assert !m.is_between?(Chronic::MiniDate.new(10,1), Chronic::MiniDate.new(12,21))
   end
-  
+
   def test_is_between_short_range
     m=Chronic::MiniDate.new(5,10)
     assert m.is_between?(Chronic::MiniDate.new(5,3), Chronic::MiniDate.new(5,12))
     assert !m.is_between?(Chronic::MiniDate.new(5,11), Chronic::MiniDate.new(5,15))
   end
-  
+
   def test_is_between_wrapping_range
     m=Chronic::MiniDate.new(1,1)
     assert m.is_between?(Chronic::MiniDate.new(11,11), Chronic::MiniDate.new(2,2))
     m=Chronic::MiniDate.new(12,12)
     assert m.is_between?(Chronic::MiniDate.new(11,11), Chronic::MiniDate.new(1,5))
   end
-  
+
 end
diff --git a/test/test_parsing.rb b/test/test_parsing.rb
index e86b7a61..932b4d23 100644
--- a/test/test_parsing.rb
+++ b/test/test_parsing.rb
@@ -1,6 +1,6 @@
 require 'helper'
 
-class TestParsing < Test::Unit::TestCase
+class TestParsing < TestCase
   # Wed Aug 16 14:00:00 UTC 2006
   TIME_2006_08_16_14_00_00 = Time.local(2006, 8, 16, 14, 0, 0, 0)
 
@@ -8,16 +8,61 @@ def setup
     @time_2006_08_16_14_00_00 = TIME_2006_08_16_14_00_00
   end
 
+  def test_handle_generic
+    time = Chronic.parse("2012-08-02T13:00:00")
+    assert_equal Time.local(2012, 8, 2, 13), time
+
+    time = Chronic.parse("2012-08-02T13:00:00+01:00")
+    assert_equal Time.utc(2012, 8, 2, 12), time
+
+    time = Chronic.parse("2012-08-02T08:00:00-04:00")
+    assert_equal Time.utc(2012, 8, 2, 12), time
+
+    time = Chronic.parse("2013-08-01T19:30:00.345-07:00")
+    time2 = Time.parse("2013-08-01 019:30:00.345-07:00")
+    assert_in_delta time, time2, 0.001
+
+    time = Chronic.parse("2013-08-01T19:30:00.34-07:00")
+    time2 = Time.parse("2013-08-01T19:30:00.34-07:00")
+    assert_in_delta time, time2, 0.001
+
+    time = Chronic.parse("2013-08-01T19:30:00.3456789-07:00")
+    time2 = Time.parse("2013-08-01T19:30:00.3456789-07:00")
+    assert_in_delta time, time2, 0.001
+
+    time = Chronic.parse("2012-08-02T12:00:00Z")
+    assert_equal Time.utc(2012, 8, 2, 12), time
+
+    time = Chronic.parse("2012-01-03 01:00:00.100")
+    time2 = Time.parse("2012-01-03 01:00:00.100")
+    assert_in_delta time, time2, 0.001
+
+    time = Chronic.parse("2012-01-03 01:00:00.234567")
+    time2 = Time.parse("2012-01-03 01:00:00.234567")
+    assert_in_delta time, time2, 0.000001
+
+    assert_nil Chronic.parse("1/1/32.1")
+
+    time = Chronic.parse("28th", {:guess => :begin})
+    assert_equal Time.new(Time.now.year, Time.now.month, 28), time
+  end
+
   def test_handle_rmn_sd
     time = parse_now("aug 3")
-    assert_equal Time.local(2006, 8, 3, 12), time
+    assert_equal Time.local(2007, 8, 3, 12), time
 
     time = parse_now("aug 3", :context => :past)
     assert_equal Time.local(2006, 8, 3, 12), time
 
+    time = parse_now("aug. 3")
+    assert_equal Time.local(2007, 8, 3, 12), time
+
     time = parse_now("aug 20")
     assert_equal Time.local(2006, 8, 20, 12), time
 
+    time = parse_now("aug-20")
+    assert_equal Time.local(2006, 8, 20, 12), time
+
     time = parse_now("aug 20", :context => :future)
     assert_equal Time.local(2006, 8, 20, 12), time
 
@@ -35,6 +80,9 @@ def test_handle_rmn_sd
 
     time = parse_now("may 28 at 5:32.19pm", :context => :past)
     assert_equal Time.local(2006, 5, 28, 17, 32, 19), time
+
+    time = parse_now("may 28 at 5:32:19.764")
+    assert_in_delta Time.local(2007, 5, 28, 17, 32, 19, 764000), time, 0.001
   end
 
   def test_handle_rmn_sd_on
@@ -65,6 +113,11 @@ def test_handle_rmn_od
     assert_equal Time.local(2007, 5, 27, 5), time
   end
 
+  def test_handle_od_rm
+    time = parse_now("fifteenth of this month")
+    assert_equal Time.local(2007, 8, 15, 12), time
+  end
+
   def test_handle_od_rmn
     time = parse_now("22nd February")
     assert_equal Time.local(2007, 2, 22, 12), time
@@ -85,6 +138,12 @@ def test_handle_sd_rmn
     time = parse_now("22 February")
     assert_equal Time.local(2007, 2, 22, 12), time
 
+    time = parse_now("22 feb")
+    assert_equal Time.local(2007, 2, 22, 12), time
+
+    time = parse_now("22-feb")
+    assert_equal Time.local(2007, 2, 22, 12), time
+
     time = parse_now("31 of may at 6:30pm")
     assert_equal Time.local(2007, 5, 31, 18, 30), time
 
@@ -115,6 +174,9 @@ def test_handle_rmn_sy
 
     time = parse_now("may 32")
     assert_equal Time.local(2032, 5, 16, 12, 0, 0), time
+
+    time = parse_now("may '01")
+    assert_equal Time.local(2001, 5, 16, 12, 0, 0), time
   end
 
   def test_handle_rdn_rmn_sd_t_tz_sy
@@ -129,8 +191,14 @@ def test_handle_sy_sm_sd_t_tz
     time = parse_now("2011-07-03 22:11:35 +01:00")
     assert_equal 1309727495, time.to_i
 
+    time = parse_now("2011-07-03 16:11:35 -05:00")
+    assert_equal 1309727495, time.to_i
+
     time = parse_now("2011-07-03 21:11:35 UTC")
     assert_equal 1309727495, time.to_i
+
+    time = parse_now("2011-07-03 21:11:35.362 UTC")
+    assert_in_delta 1309727495.362, time.to_f, 0.001
   end
 
   def test_handle_rmn_sd_sy
@@ -169,6 +237,9 @@ def test_handle_rmn_sd_sy
 
     time = parse_now("may 27 32")
     assert_equal Time.local(2032, 5, 27, 12, 0, 0), time
+
+    time = parse_now("oct 5 2012 1045pm")
+    assert_equal Time.local(2012, 10, 5, 22, 45), time
   end
 
   def test_handle_rmn_od_sy
@@ -223,6 +294,15 @@ def test_handle_sd_rmn_sy
 
     time = parse_now("27 Oct 2006 7:30pm")
     assert_equal Time.local(2006, 10, 27, 19, 30), time
+
+    time = parse_now("3 jan 10")
+    assert_equal Time.local(2010, 1, 3, 12), time
+
+    time = parse_now("3 jan 10", :endian_precedence => :little)
+    assert_equal Time.local(2010, 1, 3, 12), time
+
+    time = parse_now("3 jan 10", :endian_precedence => :middle)
+    assert_equal Time.local(2010, 1, 3, 12), time
   end
 
   def test_handle_sm_sd_sy
@@ -244,6 +324,9 @@ def test_handle_sm_sd_sy
     # month day overflows
     time = parse_now("30/2/2000")
     assert_nil time
+
+    time = parse_now("2013-03-12 17:00", :context => :past)
+    assert_equal Time.local(2013, 3, 12, 17, 0, 0), time
   end
 
   def test_handle_sd_sm_sy
@@ -252,6 +335,21 @@ def test_handle_sd_sm_sy
 
     time = parse_now("27/5/1979 @ 0700")
     assert_equal Time.local(1979, 5, 27, 7), time
+
+    time = parse_now("03/18/2012 09:26 pm")
+    assert_equal Time.local(2012, 3, 18, 21, 26), time
+
+    time = parse_now("30.07.2013 16:34:22")
+    assert_equal Time.local(2013, 7, 30, 16, 34, 22), time
+
+    time = parse_now("09.08.2013")
+    assert_equal Time.local(2013, 8, 9, 12), time
+
+    time = parse_now("9.8.2013")
+    assert_equal Time.local(2013, 8, 9, 12), time
+
+    time = parse_now("30-07-2013 21:53:49")
+    assert_equal Time.local(2013, 7, 30, 21, 53, 49), time
   end
 
   def test_handle_sy_sm_sd
@@ -276,22 +374,123 @@ def test_handle_sy_sm_sd
     time = parse_now("2006-08-20 15:30.30")
     assert_equal Time.local(2006, 8, 20, 15, 30, 30), time
 
+    time = parse_now("2006-08-20 15:30:30:000536")
+    assert_in_delta Time.local(2006, 8, 20, 15, 30, 30, 536), time, 0.000001
+
     time = parse_now("1902-08-20")
     assert_equal Time.local(1902, 8, 20, 12, 0, 0), time
+
+    time = parse_now("2013.07.30 11:45:23")
+    assert_equal Time.local(2013, 7, 30, 11, 45, 23), time
+
+    time = parse_now("2013.08.09")
+    assert_equal Time.local(2013, 8, 9, 12, 0, 0), time
+
+    # exif date time original
+    time = parse_now("2012:05:25 22:06:50")
+    assert_equal Time.local(2012, 5, 25, 22, 6, 50), time
   end
 
-  def test_handle_sm_sy
+  def test_handle_sm_sd
     time = parse_now("05/06")
-    assert_equal Time.local(2006, 5, 16, 12), time
+    assert_equal Time.local(2007, 5, 6, 12), time
 
-    time = parse_now("12/06")
-    assert_equal Time.local(2006, 12, 16, 12), time
+    time = parse_now("05/06", :endian_precedence => [:little, :medium])
+    assert_equal Time.local(2007, 6, 5, 12), time
+
+    time = parse_now("05/06 6:05:57 PM")
+    assert_equal Time.local(2007, 5, 6, 18, 05, 57), time
+
+    time = parse_now("05/06 6:05:57 PM", :endian_precedence => [:little, :medium])
+    assert_equal Time.local(2007, 6, 5, 18, 05, 57), time
+
+    time = parse_now("13/09")
+    assert_equal Time.local(2006, 9, 13, 12), time
+
+    # future
+    time = parse_now("05/06") # future is default context
+    assert_equal Time.local(2007, 5, 6, 12), time
+
+    time = parse_now("1/13", :context => :future)
+    assert_equal Time.local(2007, 1, 13, 12), time
+
+    time = parse_now("3/13", :context => :none)
+    assert_equal Time.local(2006, 3, 13, 12), time
+
+    time = parse_now("12/1", :context => :past)
+    assert_equal Time.local(2005, 12, 1, 12), time
+
+    time = parse_now("12/1", :context => :future)
+    assert_equal Time.local(2006, 12, 1, 12), time
+
+    time = parse_now("12/1", :context => :none)
+    assert_equal Time.local(2006, 12, 1, 12), time
+
+    time = parse_now("8/1", :context => :past)
+    assert_equal Time.local(2006, 8, 1, 12), time
 
-    time = parse_now("13/06")
-    assert_equal nil, time
+    time = parse_now("8/1", :context => :future)
+    assert_equal Time.local(2007, 8, 1, 12), time
+
+    time = parse_now("8/1", :context => :none)
+    assert_equal Time.local(2006, 8, 1, 12), time
+
+    time = parse_now("1/1", :context => :past)
+    assert_equal Time.local(2006, 1, 1, 12), time
+
+    time = parse_now("1/1", :context => :future)
+    assert_equal Time.local(2007, 1, 1, 12), time
+
+    time = parse_now("1/1", :context => :none)
+    assert_equal Time.local(2006, 1, 1, 12), time
+  end
+
+  # def test_handle_sm_sy
+  #   time = parse_now("05/06")
+  #   assert_equal Time.local(2006, 5, 16, 12), time
+  #
+  #   time = parse_now("12/06")
+  #   assert_equal Time.local(2006, 12, 16, 12), time
+  #
+  #   time = parse_now("13/06")
+  #   assert_nil time
+  # end
+
+  def test_handle_sy_sm
+    time = parse_now("2012-06")
+    assert_equal Time.local(2012, 06, 16), time
+
+    time = parse_now("2013/12")
+    assert_equal Time.local(2013, 12, 16, 12, 0), time
   end
 
   def test_handle_r
+    time = parse_now("9am on Saturday")
+    assert_equal Time.local(2006, 8, 19, 9), time
+
+    time = parse_now("on Tuesday")
+    assert_equal Time.local(2006, 8, 22, 12), time
+
+    time = parse_now("1:00:00 PM")
+    assert_equal Time.local(2006, 8, 16, 13), time
+
+    time = parse_now("01:00:00 PM")
+    assert_equal Time.local(2006, 8, 16, 13), time
+
+    time = parse_now("today at 02:00:00", :hours24 => false)
+    assert_equal Time.local(2006, 8, 16, 14), time
+
+    time = parse_now("today at 02:00:00 AM", :hours24 => false)
+    assert_equal Time.local(2006, 8, 16, 2), time
+
+    time = parse_now("today at 3:00:00", :hours24 => true)
+    assert_equal Time.local(2006, 8, 16, 3), time
+
+    time = parse_now("today at 03:00:00", :hours24 => true)
+    assert_equal Time.local(2006, 8, 16, 3), time
+
+    time = parse_now("tomorrow at 4a.m.")
+    assert_equal Time.local(2006, 8, 17, 4), time
   end
 
   def test_handle_r_g_r
@@ -307,6 +506,9 @@ def test_handle_p_s_r
   end
 
   def test_handle_s_r_p_a
+    time1 = parse_now("two days ago 0:0:0am")
+    time2 = parse_now("two days ago 00:00:00am")
+    assert_equal time1, time2
   end
 
   def test_handle_orr
@@ -314,7 +516,7 @@ def test_handle_orr
     assert_equal Time.local(2007, 01, 30, 12), time
 
     time = parse_now("5th tuesday in february")
-    assert_equal nil, time
+    assert_nil time
 
     %W(jan feb march april may june july aug sep oct nov dec).each_with_index do |month, index|
       time = parse_now("5th tuesday in #{month}")
@@ -330,7 +532,7 @@ def test_handle_o_r_s_r
     assert_equal Time.local(2006, 11, 15, 12), time
 
     time = parse_now("10th wednesday in november")
-    assert_equal nil, time
+    assert_nil time
 
     # time = parse_now("3rd wednesday in 2007")
     # assert_equal Time.local(2007, 1, 20, 12), time
@@ -354,6 +556,14 @@ def test_handle_o_r_g_r
     assert_equal Time.local(2006, 8, 9, 12), time
   end
 
+  def test_handle_sm_rmn_sy
+    time = parse_now('30-Mar-11')
+    assert_equal Time.local(2011, 3, 30, 12), time
+
+    time = parse_now('31-Aug-12')
+    assert_equal Time.local(2012, 8, 31), time
+  end
+
   # end of testing handlers
 
   def test_parse_guess_r
@@ -487,6 +697,12 @@ def test_parse_guess_gr
     time = parse_now("this week", :context => :past)
     assert_equal Time.local(2006, 8, 14, 19), time
 
+    time = parse_now("this week", :context => :past, :guess => :begin)
+    assert_equal Time.local(2006, 8, 13), time
+
+    time = parse_now("this week", :context => :past, :guess => :begin, :week_start => :monday)
+    assert_equal Time.local(2006, 8, 14), time
+
     # weekend
 
     time = parse_now("this weekend")
@@ -539,6 +755,34 @@ def test_parse_guess_gr
     time = parse_now("last wed")
     assert_equal Time.local(2006, 8, 9, 12), time
 
+    monday = Time.local(2006, 8, 21, 12)
+    assert_equal monday, parse_now("mon")
+    assert_equal monday, parse_now("mun")
+
+    tuesday = Time.local(2006, 8, 22, 12)
+    assert_equal tuesday, parse_now("tue")
+    assert_equal tuesday, parse_now("tus")
+
+    wednesday = Time.local(2006, 8, 23, 12)
+    assert_equal wednesday, parse_now("wed")
+    assert_equal wednesday, parse_now("wenns")
+
+    thursday = Time.local(2006, 8, 17, 12)
+    assert_equal thursday, parse_now("thu")
+    assert_equal thursday, parse_now("thur")
+
+    friday = Time.local(2006, 8, 18, 12)
+    assert_equal friday, parse_now("fri")
+    assert_equal friday, parse_now("fry")
+
+    saturday = Time.local(2006, 8, 19, 12)
+    assert_equal saturday, parse_now("sat")
+    assert_equal saturday, parse_now("satterday")
+
+    sunday = Time.local(2006, 8, 20, 12)
+    assert_equal sunday, parse_now("sun")
+    assert_equal sunday, parse_now("sum")
+
     # day portion
 
     time = parse_now("this morning")
@@ -547,13 +791,33 @@ def test_parse_guess_gr
     time = parse_now("tonight")
     assert_equal Time.local(2006, 8, 16, 22), time
 
+    # hour
+
+    time = parse_now("next hr")
+    assert_equal Time.local(2006, 8, 16, 15, 30, 0), time
+
+    time = parse_now("next hrs")
+    assert_equal Time.local(2006, 8, 16, 15, 30, 0), time
+
     # minute
 
+    time = parse_now("next min")
+    assert_equal Time.local(2006, 8, 16, 14, 1, 30), time
+
+    time = parse_now("next mins")
+    assert_equal Time.local(2006, 8, 16, 14, 1, 30), time
+
     time = parse_now("next minute")
     assert_equal Time.local(2006, 8, 16, 14, 1, 30), time
 
     # second
 
+    time = parse_now("next sec")
+    assert_equal Time.local(2006, 8, 16, 14, 0, 1), time
+
+    time = parse_now("next secs")
+    assert_equal Time.local(2006, 8, 16, 14, 0, 1), time
+
     time = parse_now("this second")
     assert_equal Time.local(2006, 8, 16, 14), time
 
@@ -646,6 +910,20 @@ def test_parse_guess_rgr
     assert_equal Time.local(2006, 8, 8, 12), time
   end
 
+  def test_parse_guess_a_ago
+    time = parse_now("AN hour ago")
+    assert_equal Time.local(2006, 8, 16, 13), time
+
+    time = parse_now("A day ago")
+    assert_equal Time.local(2006, 8, 15, 14), time
+
+    time = parse_now("a month ago")
+    assert_equal Time.local(2006, 7, 16, 14), time
+
+    time = parse_now("a year ago")
+    assert_equal Time.local(2005, 8, 16, 14), time
+  end
+
   def test_parse_guess_s_r_p
     # past
 
@@ -722,6 +1000,16 @@ def test_parse_guess_s_r_p
 
     time = Chronic.parse("2 months ago", :now => Time.parse("2007-03-07 23:30"))
     assert_equal Time.local(2007, 1, 7, 23, 30), time
+
+    # Two repeaters
+    time = parse_now("25 minutes and 20 seconds from now")
+    assert_equal Time.local(2006, 8, 16, 14, 25, 20), time
+
+    time = parse_now("24 hours and 20 minutes from now")
+    assert_equal Time.local(2006, 8, 17, 14, 20, 0), time
+
+    time = parse_now("24 hours 20 minutes from now")
+    assert_equal Time.local(2006, 8, 17, 14, 20, 0), time
   end
 
   def test_parse_guess_p_s_r
@@ -750,6 +1038,11 @@ def test_parse_guess_s_r_p_a
     # future
   end
 
+  def test_parse_guess_rmn_s_r_p
+    time = parse_now("september 3 years ago", :guess => :start)
+    assert_equal Time.local(2003, 9), time
+  end
+
   def test_parse_guess_o_r_g_r
     time = parse_now("3rd month next year", :guess => false)
     assert_equal Time.local(2007, 3), time.begin
@@ -770,10 +1063,13 @@ def test_parse_guess_o_r_g_r
 
   def test_parse_guess_nonsense
     time = parse_now("some stupid nonsense")
-    assert_equal nil, time
+    assert_nil time
 
     time = parse_now("Ham Sandwich")
-    assert_equal nil, time
+    assert_nil time
+
+    time = parse_now("t")
+    assert_nil time
   end
 
   def test_parse_span
@@ -808,6 +1104,28 @@ def test_parse_words
     assert_equal parse_now("33 days from now"), parse_now("thirty-three days from now")
     assert_equal parse_now("2867532 seconds from now"), parse_now("two million eight hundred and sixty seven thousand five hundred and thirty two seconds from now")
     assert_equal parse_now("may 10th"), parse_now("may tenth")
+    assert_equal parse_now("second monday in january"), parse_now("2nd monday in january")
+  end
+
+  def test_relative_to_an_hour_before
+    # example prenormalization "10 to 2" becomes "10 minutes past 2"
+    assert_equal Time.local(2006, 8, 16, 13, 50), parse_now("10 to 2")
+    assert_equal Time.local(2006, 8, 16, 13, 50), parse_now("10 till 2")
+    assert_equal Time.local(2006, 8, 16, 13, 50), parse_now("10 prior to 2")
+    assert_equal Time.local(2006, 8, 16, 13, 50), parse_now("10 before 2")
+
+    # uses the current hour, so 2006-08-16 13:50:00, not 14:50
+    assert_equal Time.local(2006, 8, 16, 13, 50), parse_now("10 to")
+    assert_equal Time.local(2006, 8, 16, 13, 50), parse_now("10 till")
+
+    assert_equal Time.local(2006, 8, 16, 15, 45), parse_now("quarter to 4")
+  end
+
+  def test_relative_to_an_hour_after
+    # not nil
+    assert_equal Time.local(2006, 8, 16, 14, 10), parse_now("10 after 2")
+    assert_equal Time.local(2006, 8, 16, 14, 10), parse_now("10 past 2")
+    assert_equal Time.local(2006, 8, 16, 14, 30), parse_now("half past 2")
   end
 
   def test_parse_only_complete_pointers
@@ -826,16 +1144,6 @@ def test_a_p
     assert_equal Time.local(2006, 8, 16, 18, 30), parse_now("8/16/2006 at 6:30p")
   end
 
-  def test_argument_validation
-    assert_raise(ArgumentError) do
-      time = Chronic.parse("may 27", :foo => :bar)
-    end
-
-    assert_raise(ArgumentError) do
-      time = Chronic.parse("may 27", :context => :bar)
-    end
-  end
-
   def test_seasons
     t = parse_now("this spring", :guess => false)
     assert_equal Time.local(2007, 3, 20), t.begin
@@ -858,6 +1166,236 @@ def test_seasons
     assert_equal Time.local(2007, 6, 20), t.end
   end
 
+  def test_quarters
+    time = parse_now("this quarter", :guess => false)
+    assert_equal Time.local(2006, 7, 1), time.begin
+    assert_equal Time.local(2006, 10, 1), time.end
+
+    time = parse_now("next quarter", :guess => false)
+    assert_equal Time.local(2006, 10, 1), time.begin
+    assert_equal Time.local(2007, 1, 1), time.end
+
+    time = parse_now("last quarter", :guess => false)
+    assert_equal Time.local(2006, 4, 1), time.begin
+    assert_equal Time.local(2006, 7, 1), time.end
+  end
+
+  def test_quarters_srp
+    time = parse_now("1 quarter ago", :guess => false)
+    assert_equal Time.local(2006, 4, 1), time.begin
+    assert_equal Time.local(2006, 7, 1), time.end
+
+    time = parse_now("2 quarters ago", :guess => false)
+    assert_equal Time.local(2006, 1, 1), time.begin
+    assert_equal Time.local(2006, 4, 1), time.end
+
+    time = parse_now("1 quarter from now", :guess => false)
+    assert_equal Time.local(2006, 10, 1), time.begin
+    assert_equal Time.local(2007, 1, 1), time.end
+  end
+
+  def test_quarters_named
+    ["Q1", "first quarter", "1st quarter"].each do |string|
+      time = parse_now(string, :guess => false, :context => :none)
+      assert_equal Time.local(2006, 1, 1), time.begin
+      assert_equal Time.local(2006, 4, 1), time.end
+
+      time = parse_now(string, :guess => false, :context => :future)
+      assert_equal Time.local(2007, 1, 1), time.begin
+      assert_equal Time.local(2007, 4, 1), time.end
+
+      time = parse_now(string, :guess => false, :context => :past)
+      assert_equal Time.local(2006, 1, 1), time.begin
+      assert_equal Time.local(2006, 4, 1), time.end
+
+      time = parse_now("#{string} 2005", :guess => false)
+      assert_equal Time.local(2005, 1, 1), time.begin
+      assert_equal Time.local(2005, 4, 1), time.end
+
+      time = parse_now("2005 #{string}", :guess => false)
+      assert_equal Time.local(2005, 1, 1), time.begin
+      assert_equal Time.local(2005, 4, 1), time.end
+
+      time = parse_now("#{string} this year", :guess => false)
+      assert_equal Time.local(2006, 1, 1), time.begin
+      assert_equal Time.local(2006, 4, 1), time.end
+
+      time = parse_now("this year #{string}", :guess => false)
+      assert_equal Time.local(2006, 1, 1), time.begin
+      assert_equal Time.local(2006, 4, 1), time.end
+
+      time = parse_now("#{string} next year", :guess => false)
+      assert_equal Time.local(2007, 1, 1), time.begin
+      assert_equal Time.local(2007, 4, 1), time.end
+
+      time = parse_now("next year #{string}", :guess => false)
+      assert_equal Time.local(2007, 1, 1), time.begin
+      assert_equal Time.local(2007, 4, 1), time.end
+
+      time = parse_now("this #{string}", :guess => false, context: :none)
+      assert_equal Time.local(2006, 1, 1), time.begin
+      assert_equal Time.local(2006, 4, 1), time.end
+
+      time = parse_now("last #{string}", :guess => false, context: :none)
+      assert_equal Time.local(2006, 1, 1), time.begin
+      assert_equal Time.local(2006, 4, 1), time.end
+
+      time = parse_now("next #{string}", :guess => false, context: :none)
+      assert_equal Time.local(2007, 1, 1), time.begin
+      assert_equal Time.local(2007, 4, 1), time.end
+    end
+
+    ["Q2", "second quarter", "2nd quarter"].each do |string|
+      time = parse_now(string, :guess => false, :context => :none)
+      assert_equal Time.local(2006, 4, 1), time.begin
+      assert_equal Time.local(2006, 7, 1), time.end
+
+      time = parse_now(string, :guess => false, :context => :future)
+      assert_equal Time.local(2007, 4, 1), time.begin
+      assert_equal Time.local(2007, 7, 1), time.end
+
+      time = parse_now(string, :guess => false, :context => :past)
+      assert_equal Time.local(2006, 4, 1), time.begin
+      assert_equal Time.local(2006, 7, 1), time.end
+
+      time = parse_now("#{string} 2005", :guess => false)
+      assert_equal Time.local(2005, 4, 1), time.begin
+      assert_equal Time.local(2005, 7, 1), time.end
+
+      time = parse_now("2005 #{string}", :guess => false)
+      assert_equal Time.local(2005, 4, 1), time.begin
+      assert_equal Time.local(2005, 7, 1), time.end
+
+      time = parse_now("#{string} this year", :guess => false)
+      assert_equal Time.local(2006, 4, 1), time.begin
+      assert_equal Time.local(2006, 7, 1), time.end
+
+      time = parse_now("this year #{string}", :guess => false)
+      assert_equal Time.local(2006, 4, 1), time.begin
+      assert_equal Time.local(2006, 7, 1), time.end
+
+      time = parse_now("#{string} next year", :guess => false)
+      assert_equal Time.local(2007, 4, 1), time.begin
+      assert_equal Time.local(2007, 7, 1), time.end
+
+      time = parse_now("next year #{string}", :guess => false)
+      assert_equal Time.local(2007, 4, 1), time.begin
+      assert_equal Time.local(2007, 7, 1), time.end
+
+      time = parse_now("this #{string}", :guess => false, context: :none)
+      assert_equal Time.local(2006, 4, 1), time.begin
+      assert_equal Time.local(2006, 7, 1), time.end
+
+      time = parse_now("last #{string}", :guess => false, context: :none)
+      assert_equal Time.local(2006, 4, 1), time.begin
+      assert_equal Time.local(2006, 7, 1), time.end
+
+      time = parse_now("next #{string}", :guess => false, context: :none)
+      assert_equal Time.local(2007, 4, 1), time.begin
+      assert_equal Time.local(2007, 7, 1), time.end
+    end
+
+    ["Q3", "third quarter", "3rd quarter"].each do |string|
+      time = parse_now(string, :guess => false, :context => :none)
+      assert_equal Time.local(2006, 7, 1), time.begin
+      assert_equal Time.local(2006, 10, 1), time.end
+
+      time = parse_now(string, :guess => false, :context => :future)
+      assert_equal Time.local(2007, 7, 1), time.begin
+      assert_equal Time.local(2007, 10, 1), time.end
+
+      time = parse_now(string, :guess => false, :context => :past)
+      assert_equal Time.local(2005, 7, 1), time.begin
+      assert_equal Time.local(2005, 10, 1), time.end
+
+      time = parse_now("#{string} 2005", :guess => false)
+      assert_equal Time.local(2005, 7, 1), time.begin
+      assert_equal Time.local(2005, 10, 1), time.end
+
+      time = parse_now("2005 #{string}", :guess => false)
+      assert_equal Time.local(2005, 7, 1), time.begin
+      assert_equal Time.local(2005, 10, 1), time.end
+
+      time = parse_now("#{string} this year", :guess => false)
+      assert_equal Time.local(2006, 7, 1), time.begin
+      assert_equal Time.local(2006, 10, 1), time.end
+
+      time = parse_now("this year #{string}", :guess => false)
+      assert_equal Time.local(2006, 7, 1), time.begin
+      assert_equal Time.local(2006, 10, 1), time.end
+
+      time = parse_now("#{string} next year", :guess => false)
+      assert_equal Time.local(2007, 7, 1), time.begin
+      assert_equal Time.local(2007, 10, 1), time.end
+
+      time = parse_now("next year #{string}", :guess => false)
+      assert_equal Time.local(2007, 7, 1), time.begin
+      assert_equal Time.local(2007, 10, 1), time.end
+
+      time = parse_now("this #{string}", :guess => false, context: :none)
+      assert_equal Time.local(2006, 7, 1), time.begin
+      assert_equal Time.local(2006, 10, 1), time.end
+
+      time = parse_now("last #{string}", :guess => false, context: :none)
+      assert_equal Time.local(2005, 7, 1), time.begin
+      assert_equal Time.local(2005, 10, 1), time.end
+
+      time = parse_now("next #{string}", :guess => false, context: :none)
+      assert_equal Time.local(2007, 7, 1), time.begin
+      assert_equal Time.local(2007, 10, 1), time.end
+    end
+
+    ["Q4", "fourth quarter", "4th quarter"].each do |string|
+      time = parse_now(string, :guess => false, :context => :none)
+      assert_equal Time.local(2006, 10, 1), time.begin
+      assert_equal Time.local(2007, 1, 1), time.end
+
+      time = parse_now(string, :guess => false, :context => :future)
+      assert_equal Time.local(2006, 10, 1), time.begin
+      assert_equal Time.local(2007, 1, 1), time.end
+
+      time = parse_now(string, :guess => false, :context => :past)
+      assert_equal Time.local(2005, 10, 1), time.begin
+      assert_equal Time.local(2006, 1, 1), time.end
+
+      time = parse_now("#{string} 2005", :guess => false)
+      assert_equal Time.local(2005, 10, 1), time.begin
+      assert_equal Time.local(2006, 1, 1), time.end
+
+      time = parse_now("2005 #{string}", :guess => false)
+      assert_equal Time.local(2005, 10, 1), time.begin
+      assert_equal Time.local(2006, 1, 1), time.end
+
+      time = parse_now("#{string} this year", :guess => false)
+      assert_equal Time.local(2006, 10, 1), time.begin
+      assert_equal Time.local(2007, 1, 1), time.end
+
+      time = parse_now("this year #{string}", :guess => false)
+      assert_equal Time.local(2006, 10, 1), time.begin
+      assert_equal Time.local(2007, 1, 1), time.end
+
+      time = parse_now("#{string} next year", :guess => false)
+      assert_equal Time.local(2007, 10, 1), time.begin
+      assert_equal Time.local(2008, 1, 1), time.end
+
+      time = parse_now("next year #{string}", :guess => false)
+      assert_equal Time.local(2007, 10, 1), time.begin
+      assert_equal Time.local(2008, 1, 1), time.end
+
+      time = parse_now("this #{string}", :guess => false, context: :none)
+      assert_equal Time.local(2006, 10, 1), time.begin
+      assert_equal Time.local(2007, 1, 1), time.end
+
+      time = parse_now("last #{string}", :guess => false, context: :none)
+      assert_equal Time.local(2005, 10, 1), time.begin
+      assert_equal Time.local(2006, 1, 1), time.end
+
+      time = parse_now("next #{string}", :guess => false, context: :none)
+      assert_equal Time.local(2006, 10, 1), time.begin
+      assert_equal Time.local(2007, 1, 1), time.end
+    end
+  end
+
   # regression
 
   # def test_partial
@@ -887,7 +1425,7 @@ def test_now_changes
     t1 = Chronic.parse("now")
     sleep 0.1
     t2 = Chronic.parse("now")
-    assert_not_equal t1, t2
+    refute_equal t1, t2
   end
 
   def test_noon
@@ -898,15 +1436,98 @@ def test_noon
   def test_handle_rdn_rmn_sd
     time = parse_now("Thu Aug 10")
     assert_equal Time.local(2006, 8, 10, 12), time
+
+    time = parse_now("Thursday July 31")
+    assert_equal Time.local(2006, 7, 31, 12), time
+
+    time = parse_now("Thursday December 31")
+    assert_equal Time.local(2006, 12, 31, 12), time
+  end
+
+  def test_handle_rdn_rmn_sd_rt
+    time = parse_now("Thu Aug 10 4pm")
+    assert_equal Time.local(2006, 8, 10, 16), time
+
+    time = parse_now("Thu Aug 10 at 4pm")
+    assert_equal Time.local(2006, 8, 10, 16), time
+  end
+
+  def test_handle_rdn_rmn_od_rt
+    time = parse_now("Thu Aug 10th at 4pm")
+    assert_equal Time.local(2006, 8, 10, 16), time
+  end
+
+  def test_handle_rdn_od_rt
+    time = parse_now("Thu 17th at 4pm")
+    assert_equal Time.local(2006, 8, 17, 16), time
+
+    time = parse_now("Thu 16th at 4pm")
+    assert_equal Time.local(2006, 8, 16, 16), time
+
+    time = parse_now("Thu 1st at 4pm")
+    assert_equal Time.local(2006, 9, 1, 16), time
+
+    time = parse_now("Thu 1st at 4pm", :context => :past)
+    assert_equal Time.local(2006, 8, 1, 16), time
+  end
+
+  def test_handle_rdn_od
+    time = parse_now("Thu 17th")
+    assert_equal Time.local(2006, 8, 17, 12), time
+  end
+
+  def test_handle_rdn_rmn_sd_sy
+    time = parse_now("Thu Aug 10 2006")
+    assert_equal Time.local(2006, 8, 10, 12), time
+
+    time = parse_now("Thursday July 31 2006")
+    assert_equal Time.local(2006, 7, 31, 12), time
+
+    time = parse_now("Thursday December 31 2006")
+    assert_equal Time.local(2006, 12, 31, 12), time
+
+    time = parse_now("Thursday December 30 2006")
+    assert_equal Time.local(2006, 12, 30, 12), time
   end
 
   def test_handle_rdn_rmn_od
     time = parse_now("Thu Aug 10th")
     assert_equal Time.local(2006, 8, 10, 12), time
+
+    time = parse_now("Thursday July 31st")
+    assert_equal Time.local(2006, 7, 31, 12), time
+
+    time = parse_now("Thursday December 31st")
+    assert_equal Time.local(2006, 12, 31, 12), time
+  end
+
+  def test_handle_rdn_rmn_od_sy
+    time = parse_now("Thu Aug 10th 2005")
+    assert_equal Time.local(2005, 8, 10, 12), time
+
+    time = parse_now("Thursday July 31st 2005")
+    assert_equal Time.local(2005, 7, 31, 12), time
+
+    time = parse_now("Thursday December 31st 2005")
+    assert_equal Time.local(2005, 12, 31, 12), time
+
+    time = parse_now("Thursday December 30th 2005")
+    assert_equal Time.local(2005, 12, 30, 12), time
+  end
+
+  def test_normalizing_day_portions
+    assert_equal pre_normalize("8:00 pm February 11"), pre_normalize("8:00 p.m. February 11")
+  end
+
+  def test_normalizing_time_of_day_phrases
+    assert_equal pre_normalize("midday February 11"), pre_normalize("12:00 p.m. February 11")
   end
 
   private
   def parse_now(string, options={})
     Chronic.parse(string, {:now => TIME_2006_08_16_14_00_00 }.merge(options))
   end
+  def pre_normalize(s)
+    Chronic::Parser.new.pre_normalize s
+  end
 end
diff --git a/test/test_RepeaterDayName.rb b/test/test_repeater_day_name.rb
similarity index 96%
rename from test/test_RepeaterDayName.rb
rename to test/test_repeater_day_name.rb
index 21562a2c..7fa7f0da 100644
--- a/test/test_RepeaterDayName.rb
+++ b/test/test_repeater_day_name.rb
@@ -1,6 +1,6 @@
 require 'helper'
 
-class TestRepeaterDayName < Test::Unit::TestCase
+class TestRepeaterDayName < TestCase
 
   def setup
     @now = Time.local(2006, 8, 16, 14, 0, 0, 0)
diff --git a/test/test_repeater_day_portion.rb b/test/test_repeater_day_portion.rb
new file mode 100644
index 00000000..1959c21e
--- /dev/null
+++ b/test/test_repeater_day_portion.rb
@@ -0,0 +1,254 @@
+require 'helper'
+
+class TestRepeaterDayPortion < TestCase
+
+  def setup
+    @now = Time.local(2006, 8, 16, 14, 0, 0, 0)
+  end
+  
+  def test_am_future
+    day_portion = Chronic::RepeaterDayPortion.new(:am)
+    day_portion.start = @now
+    
+    next_time = day_portion.next(:future)
+    assert_equal Time.local(2006, 8, 17, 00), next_time.begin
+    assert_equal Time.local(2006, 8, 17, 11, 59, 59), next_time.end
+
+    next_next_time = day_portion.next(:future)
+    assert_equal Time.local(2006, 8, 18, 00), next_next_time.begin
+    assert_equal Time.local(2006, 8, 18, 11, 59, 59), next_next_time.end
+  end
+
+  def test_am_past
+    day_portion = Chronic::RepeaterDayPortion.new(:am)
+    day_portion.start = @now
+    
+    next_time = day_portion.next(:past)
+    assert_equal Time.local(2006, 8, 16, 00), next_time.begin
+    assert_equal Time.local(2006, 8, 16, 11, 59, 59), next_time.end
+
+    next_next_time = day_portion.next(:past)
+    assert_equal Time.local(2006, 8, 15, 00), next_next_time.begin
+    assert_equal Time.local(2006, 8, 15, 11, 59, 59), next_next_time.end
+  end
+  
+  def test_am_future_with_daylight_savings_time_boundary
+    @now = Time.local(2012,11,3,0,0,0)
+    day_portion = Chronic::RepeaterDayPortion.new(:am)
+    day_portion.start = @now
+    
+    next_time = day_portion.next(:future)
+    assert_equal Time.local(2012, 11, 4, 00), next_time.begin
+    assert_equal Time.local(2012, 11, 4, 11, 59, 59), next_time.end
+
+    next_next_time = day_portion.next(:future)
+
+    assert_equal Time.local(2012, 11, 5, 00), next_next_time.begin
+    assert_equal Time.local(2012, 11, 5, 11, 59, 59), next_next_time.end
+  end
+
+  def test_pm_future
+    day_portion = Chronic::RepeaterDayPortion.new(:pm)
+    day_portion.start = @now
+    
+    next_time = day_portion.next(:future)
+    assert_equal Time.local(2006, 8, 17, 12), next_time.begin
+    assert_equal Time.local(2006, 8, 17, 23, 59, 59), next_time.end
+
+    next_next_time = day_portion.next(:future)
+    assert_equal Time.local(2006, 8, 18, 12), next_next_time.begin
+    assert_equal Time.local(2006, 8, 18, 23, 59, 59), next_next_time.end
+  end
+
+  def test_pm_past
+    day_portion = Chronic::RepeaterDayPortion.new(:pm)
+    day_portion.start = @now
+    
+    next_time = day_portion.next(:past)
+    assert_equal Time.local(2006, 8, 15, 12), next_time.begin
+    assert_equal Time.local(2006, 8, 15, 23, 59, 59), next_time.end
+
+    next_next_time = day_portion.next(:past)
+    assert_equal Time.local(2006, 8, 14, 12), next_next_time.begin
+    assert_equal Time.local(2006, 8, 14, 23, 59, 59), next_next_time.end
+  end
+  
+  def test_pm_future_with_daylight_savings_time_boundary
+    @now = Time.local(2012,11,3,0,0,0)
+    day_portion = Chronic::RepeaterDayPortion.new(:pm)
+    day_portion.start = @now
+    
+    next_time = day_portion.next(:future)
+    assert_equal Time.local(2012, 11, 3, 12), next_time.begin
+    assert_equal Time.local(2012, 11, 3, 23, 59, 59), next_time.end
+
+    next_next_time = day_portion.next(:future)
+
+    assert_equal Time.local(2012, 11, 4, 12), next_next_time.begin
+    assert_equal Time.local(2012, 11, 4, 23, 59, 59), next_next_time.end
+  end
+
+  def test_morning_future
+    day_portion = Chronic::RepeaterDayPortion.new(:morning)
+    day_portion.start = @now
+    
+    next_time = day_portion.next(:future)
+    assert_equal Time.local(2006, 8, 17, 6), next_time.begin
+    assert_equal Time.local(2006, 8, 17, 12), next_time.end
+
+    next_next_time = day_portion.next(:future)
+    assert_equal Time.local(2006, 8, 18, 6), next_next_time.begin
+    assert_equal Time.local(2006, 8, 18, 12), next_next_time.end
+  end
+
+  def test_morning_past
+    day_portion = Chronic::RepeaterDayPortion.new(:morning)
+    day_portion.start = @now
+    
+    next_time = day_portion.next(:past)
+    assert_equal Time.local(2006, 8, 16, 6), next_time.begin
+    assert_equal Time.local(2006, 8, 16, 12), next_time.end
+
+    next_next_time = day_portion.next(:past)
+    assert_equal Time.local(2006, 8, 15, 6), next_next_time.begin
+    assert_equal Time.local(2006, 8, 15, 12), next_next_time.end
+  end
+  
+  def test_morning_future_with_daylight_savings_time_boundary
+    @now = Time.local(2012,11,3,0,0,0)
+    day_portion = Chronic::RepeaterDayPortion.new(:morning)
+    day_portion.start = @now
+    
+    next_time = day_portion.next(:future)
+    assert_equal Time.local(2012, 11, 3, 6), next_time.begin
+    assert_equal Time.local(2012, 11, 3, 12), next_time.end
+
+    next_next_time = day_portion.next(:future)
+
+    assert_equal Time.local(2012, 11, 4, 6), next_next_time.begin
+    assert_equal Time.local(2012, 11, 4, 12), next_next_time.end
+  end
+
+  def test_afternoon_future
+    day_portion = Chronic::RepeaterDayPortion.new(:afternoon)
+    day_portion.start = @now
+    
+    next_time = day_portion.next(:future)
+    assert_equal Time.local(2006, 8, 17, 13), next_time.begin
+    assert_equal Time.local(2006, 8, 17, 17), next_time.end
+
+    next_next_time = day_portion.next(:future)
+    assert_equal Time.local(2006, 8, 18, 13), next_next_time.begin
+    assert_equal Time.local(2006, 8, 18, 17), next_next_time.end
+  end
+
+  def test_afternoon_past
+    day_portion = Chronic::RepeaterDayPortion.new(:afternoon)
+    day_portion.start = @now
+    
+    next_time = day_portion.next(:past)
+    assert_equal Time.local(2006, 8, 15, 13), next_time.begin
+    assert_equal Time.local(2006, 8, 15, 17), next_time.end
+
+    next_next_time = day_portion.next(:past)
+    assert_equal Time.local(2006, 8, 14, 13), next_next_time.begin
+    assert_equal Time.local(2006, 8, 14, 17), next_next_time.end
+  end
+  
+  def test_afternoon_future_with_daylight_savings_time_boundary
+    @now = Time.local(2012,11,3,0,0,0)
+    day_portion = Chronic::RepeaterDayPortion.new(:afternoon)
+    day_portion.start = @now
+    
+    next_time = day_portion.next(:future)
+    assert_equal Time.local(2012, 11, 3, 13), next_time.begin
+    assert_equal Time.local(2012, 11, 3, 17), next_time.end
+
+    next_next_time = day_portion.next(:future)
+
+    assert_equal Time.local(2012, 11, 4, 13), next_next_time.begin
+    assert_equal Time.local(2012, 11, 4, 17), next_next_time.end
+  end
+
+  def test_evening_future
+    day_portion = Chronic::RepeaterDayPortion.new(:evening)
+    day_portion.start = @now
+    
+    next_time = day_portion.next(:future)
+    assert_equal Time.local(2006, 8, 16, 17), next_time.begin
+    assert_equal Time.local(2006, 8, 16, 20), next_time.end
+
+    next_next_time = day_portion.next(:future)
+    assert_equal Time.local(2006, 8, 17, 17), next_next_time.begin
+    assert_equal Time.local(2006, 8, 17, 20), next_next_time.end
+  end
+
+  def test_evening_past
+    day_portion = Chronic::RepeaterDayPortion.new(:evening)
+    day_portion.start = @now
+    
+    next_time = day_portion.next(:past)
+    assert_equal Time.local(2006, 8, 15, 17), next_time.begin
+    assert_equal Time.local(2006, 8, 15, 20), next_time.end
+
+    next_next_time = day_portion.next(:past)
+    assert_equal Time.local(2006, 8, 14, 17), next_next_time.begin
+    assert_equal Time.local(2006, 8, 14, 20), next_next_time.end
+  end
+  
+  def test_evening_future_with_daylight_savings_time_boundary
+    @now = Time.local(2012,11,3,0,0,0)
+    day_portion = Chronic::RepeaterDayPortion.new(:evening)
+    day_portion.start = @now
+    
+    next_time = day_portion.next(:future)
+    assert_equal Time.local(2012, 11, 3, 17), next_time.begin
+    assert_equal Time.local(2012, 11, 3, 20), next_time.end
+
+    next_next_time = day_portion.next(:future)
+
+    assert_equal Time.local(2012, 11, 4, 17), next_next_time.begin
+    assert_equal Time.local(2012, 11, 4, 20), next_next_time.end
+  end
+
+  def test_night_future
+    day_portion = Chronic::RepeaterDayPortion.new(:night)
+    day_portion.start = @now
+    
+    next_time = day_portion.next(:future)
+    assert_equal Time.local(2006, 8, 16, 20), next_time.begin
+    assert_equal Time.local(2006, 8, 17, 0), next_time.end
+
+    next_next_time = day_portion.next(:future)
+    assert_equal Time.local(2006, 8, 17, 20), next_next_time.begin
+    assert_equal Time.local(2006, 8, 18, 0), next_next_time.end
+  end
+
+  def test_night_past
+    day_portion = Chronic::RepeaterDayPortion.new(:night)
+    day_portion.start = @now
+    
+    next_time = day_portion.next(:past)
+    assert_equal Time.local(2006, 8, 15, 20), next_time.begin
+    assert_equal Time.local(2006, 8, 16, 0), next_time.end
+
+    next_next_time = day_portion.next(:past)
+    assert_equal Time.local(2006, 8, 14, 20), next_next_time.begin
+    assert_equal Time.local(2006, 8, 15, 0), next_next_time.end
+  end
+  
+  def test_night_future_with_daylight_savings_time_boundary
+    @now = Time.local(2012,11,3,0,0,0)
+    day_portion = Chronic::RepeaterDayPortion.new(:night)
+    day_portion.start = @now
+    
+    next_time = day_portion.next(:future)
+    assert_equal Time.local(2012, 11, 3, 20), next_time.begin
+    assert_equal Time.local(2012, 11, 4, 0), next_time.end
+
+    next_next_time = day_portion.next(:future)
+
+    assert_equal Time.local(2012, 11, 4, 20), next_next_time.begin
+    assert_equal Time.local(2012, 11, 5, 0), next_next_time.end
+  end
+end
diff --git a/test/test_RepeaterFortnight.rb b/test/test_repeater_fortnight.rb
similarity index 97%
rename from test/test_RepeaterFortnight.rb
rename to test/test_repeater_fortnight.rb
index 6df9b72f..d1fb0cf5 100644
--- a/test/test_RepeaterFortnight.rb
+++ b/test/test_repeater_fortnight.rb
@@ -1,6 +1,6 @@
 require 'helper'
 
-class TestRepeaterFortnight < Test::Unit::TestCase
+class TestRepeaterFortnight < TestCase
 
   def setup
     @now = Time.local(2006, 8, 16, 14, 0, 0, 0)
diff --git a/test/test_RepeaterHour.rb b/test/test_repeater_hour.rb
similarity index 97%
rename from test/test_RepeaterHour.rb
rename to test/test_repeater_hour.rb
index 27ede67e..d729e5ce 100644
--- a/test/test_RepeaterHour.rb
+++ b/test/test_repeater_hour.rb
@@ -1,6 +1,6 @@
 require 'helper'
 
-class TestRepeaterHour < Test::Unit::TestCase
+class TestRepeaterHour < TestCase
 
   def setup
     @now = Time.local(2006, 8, 16, 14, 0, 0, 0)
diff --git a/test/test_RepeaterMinute.rb b/test/test_repeater_minute.rb
similarity index 95%
rename from test/test_RepeaterMinute.rb
rename to test/test_repeater_minute.rb
index 95408385..a04f8b0e 100644
--- a/test/test_RepeaterMinute.rb
+++ b/test/test_repeater_minute.rb
@@ -1,6 +1,6 @@
 require 'helper'
 
-class TestRepeaterMinute < Test::Unit::TestCase
+class TestRepeaterMinute < TestCase
 
   def setup
     @now = Time.local(2008, 6, 25, 7, 15, 30, 0)
diff --git a/test/test_RepeaterMonth.rb b/test/test_repeater_month.rb
similarity index 96%
rename from test/test_RepeaterMonth.rb
rename to test/test_repeater_month.rb
index b05ac310..73f3dfc9 100644
--- a/test/test_RepeaterMonth.rb
+++ b/test/test_repeater_month.rb
@@ -1,6 +1,6 @@
 require 'helper'
 
-class TestRepeaterMonth < Test::Unit::TestCase
+class TestRepeaterMonth < TestCase
 
   def setup
     # Wed Aug 16 14:00:00 2006
diff --git a/test/test_RepeaterMonthName.rb b/test/test_repeater_month_name.rb
similarity index 96%
rename from test/test_RepeaterMonthName.rb
rename to test/test_repeater_month_name.rb
index 36a3e65e..45a7c8c4 100644
--- a/test/test_RepeaterMonthName.rb
+++ b/test/test_repeater_month_name.rb
@@ -1,6 +1,6 @@
 require 'helper'
 
-class TestRepeaterMonthName < Test::Unit::TestCase
+class TestRepeaterMonthName < TestCase
 
   def setup
     # Wed Aug 16 14:00:00 2006
diff --git a/test/test_repeater_quarter.rb b/test/test_repeater_quarter.rb
new file mode 100644
index 00000000..1cccb592
--- /dev/null
+++ b/test/test_repeater_quarter.rb
@@ -0,0 +1,70 @@
+require 'helper'
+
+class TestRepeaterQuarter < TestCase
+  def setup
+    @now = Time.local(2006, 8, 16, 14, 0, 0, 0)
+  end
+
+  def test_match
+    token = Chronic::Token.new('q')
+    repeater = Chronic::Repeater.scan_for_units(token)
+    assert_equal Chronic::RepeaterQuarter, repeater.class
+    assert_equal :quarter, repeater.type
+  end
+
+  def test_this
+    quarter = Chronic::RepeaterQuarter.new(:quarter)
+    quarter.start = @now
+
+    time = quarter.this
+    assert_equal Time.local(2006, 7, 1), time.begin
+    assert_equal Time.local(2006, 10, 1), time.end
+  end
+
+  def test_next_future
+    quarter = Chronic::RepeaterQuarter.new(:quarter)
+    quarter.start = @now
+
+    time = quarter.next(:future)
+    assert_equal Time.local(2006, 10, 1), time.begin
+    assert_equal Time.local(2007, 1, 1), time.end
+
+    time = quarter.next(:future)
+    assert_equal Time.local(2007, 1, 1), time.begin
+    assert_equal Time.local(2007, 4, 1), time.end
+
+    time = quarter.next(:future)
+    assert_equal Time.local(2007, 4, 1), time.begin
+    assert_equal Time.local(2007, 7, 1), time.end
+  end
+
+  def test_next_past
+    quarter = Chronic::RepeaterQuarter.new(:quarter)
+    quarter.start = @now
+
+    time = quarter.next(:past)
+    assert_equal Time.local(2006, 4, 1), time.begin
+    assert_equal Time.local(2006, 7, 1), time.end
+
+    time = quarter.next(:past)
+    assert_equal Time.local(2006, 1, 1), time.begin
+    assert_equal Time.local(2006, 4, 1), time.end
+
+    time = quarter.next(:past)
+    assert_equal Time.local(2005, 10, 1), time.begin
+    assert_equal Time.local(2006, 1, 1), time.end
+  end
+
+  def test_offset
+    quarter = Chronic::RepeaterQuarter.new(:quarter)
+    span = Chronic::Span.new(@now, @now + 1)
+
+    time = quarter.offset(span, 1, :future)
+    assert_equal Time.local(2006, 10, 1), time.begin
+    assert_equal Time.local(2007, 1, 1), time.end
+
+    time = quarter.offset(span, 1, :past)
+    assert_equal Time.local(2006, 4, 1), time.begin
+    assert_equal Time.local(2006, 7, 1), time.end
+  end
+end
diff --git a/test/test_repeater_quarter_name.rb b/test/test_repeater_quarter_name.rb
new file mode 100644
index 00000000..47999c15
--- /dev/null
+++ b/test/test_repeater_quarter_name.rb
@@ -0,0 +1,198 @@
+require 'helper'
+
+class TestRepeaterQuarterName < TestCase
+  def setup
+    @now = Time.local(2006, 8, 16, 14, 0, 0, 0)
+  end
+
+  def test_match
+    %w[q1 q2 q3 q4].each do |string|
+      token = Chronic::Token.new(string)
+      repeater = Chronic::Repeater.scan_for_quarter_names(token)
+      assert_equal Chronic::RepeaterQuarterName, repeater.class
+      assert_equal string.to_sym, repeater.type
+    end
+  end
+
+  def test_this_none
+    quarter = Chronic::RepeaterQuarterName.new(:q1)
+    quarter.start = @now
+
+    time = quarter.this(:none)
+    assert_equal Time.local(2006, 1, 1), time.begin
+    assert_equal Time.local(2006, 4, 1), time.end
+
+    quarter = Chronic::RepeaterQuarterName.new(:q2)
+    quarter.start = @now
+
+    time = quarter.this(:none)
+    assert_equal Time.local(2006, 4, 1), time.begin
+    assert_equal Time.local(2006, 7, 1), time.end
+
+    quarter = Chronic::RepeaterQuarterName.new(:q3)
+    quarter.start = @now
+
+    time = quarter.this(:none)
+    assert_equal Time.local(2006, 7, 1), time.begin
+    assert_equal Time.local(2006, 10, 1), time.end
+
+    quarter = Chronic::RepeaterQuarterName.new(:q4)
+    quarter.start = @now
+
+    time = quarter.this(:none)
+    assert_equal Time.local(2006, 10, 1), time.begin
+    assert_equal Time.local(2007, 1, 1), time.end
+  end
+
+  def test_this_past
+    quarter = Chronic::RepeaterQuarterName.new(:q1)
+    quarter.start = @now
+
+    time = quarter.this(:past)
+    assert_equal Time.local(2006, 1, 1), time.begin
+    assert_equal Time.local(2006, 4, 1), time.end
+
+    quarter = Chronic::RepeaterQuarterName.new(:q2)
+    quarter.start = @now
+
+    time = quarter.this(:past)
+    assert_equal Time.local(2006, 4, 1), time.begin
+    assert_equal Time.local(2006, 7, 1), time.end
+
+    quarter = Chronic::RepeaterQuarterName.new(:q3)
+    quarter.start = @now
+
+    time = quarter.this(:past)
+    assert_equal Time.local(2005, 7, 1), time.begin
+    assert_equal Time.local(2005, 10, 1), time.end
+
+    quarter = Chronic::RepeaterQuarterName.new(:q4)
+    quarter.start = @now
+
+    time = quarter.this(:past)
+    assert_equal Time.local(2005, 10, 1), time.begin
+    assert_equal Time.local(2006, 1, 1), time.end
+  end
+
+  def test_this_future
+    quarter = Chronic::RepeaterQuarterName.new(:q1)
+    quarter.start = @now
+
+    time = quarter.this(:future)
+    assert_equal Time.local(2007, 1, 1), time.begin
+    assert_equal Time.local(2007, 4, 1), time.end
+
+    quarter = Chronic::RepeaterQuarterName.new(:q2)
+    quarter.start = @now
+
+    time = quarter.this(:future)
+    assert_equal Time.local(2007, 4, 1), time.begin
+    assert_equal Time.local(2007, 7, 1), time.end
+
+    quarter = Chronic::RepeaterQuarterName.new(:q3)
+    quarter.start = @now
+
+    time = quarter.this(:future)
+    assert_equal Time.local(2007, 7, 1), time.begin
+    assert_equal Time.local(2007, 10, 1), time.end
+
+    quarter = Chronic::RepeaterQuarterName.new(:q4)
+    quarter.start = @now
+
+    time = quarter.this(:future)
+    assert_equal Time.local(2006, 10, 1), time.begin
+    assert_equal Time.local(2007, 1, 1), time.end
+  end
+
+  def test_next_future
+    quarter = Chronic::RepeaterQuarterName.new(:q1)
+    quarter.start = @now
+
+    time = quarter.next(:future)
+    assert_equal Time.local(2007, 1, 1), time.begin
+    assert_equal Time.local(2007, 4, 1), time.end
+
+    time = quarter.next(:future)
+    assert_equal Time.local(2008, 1, 1), time.begin
+    assert_equal Time.local(2008, 4, 1), time.end
+
+    quarter = Chronic::RepeaterQuarterName.new(:q2)
+    quarter.start = @now
+
+    time = quarter.next(:future)
+    assert_equal Time.local(2007, 4, 1), time.begin
+    assert_equal Time.local(2007, 7, 1), time.end
+
+    time = quarter.next(:future)
+    assert_equal Time.local(2008, 4, 1), time.begin
+    assert_equal Time.local(2008, 7, 1), time.end
+
+    quarter = Chronic::RepeaterQuarterName.new(:q3)
+    quarter.start = @now
+
+    time = quarter.next(:future)
+    assert_equal Time.local(2007, 7, 1), time.begin
+    assert_equal Time.local(2007, 10, 1), time.end
+
+    time = quarter.next(:future)
+    assert_equal Time.local(2008, 7, 1), time.begin
+    assert_equal Time.local(2008, 10, 1), time.end
+
+    quarter = Chronic::RepeaterQuarterName.new(:q4)
+    quarter.start = @now
+
+    time = quarter.next(:future)
+    assert_equal Time.local(2006, 10, 1), time.begin
+    assert_equal Time.local(2007, 1, 1), time.end
+
+    time = quarter.next(:future)
+    assert_equal Time.local(2007, 10, 1), time.begin
+    assert_equal Time.local(2008, 1, 1), time.end
+  end
+
+  def test_next_past
+    quarter = Chronic::RepeaterQuarterName.new(:q1)
+    quarter.start = @now
+
+    time = quarter.next(:past)
+    assert_equal Time.local(2006, 1, 1), time.begin
+    assert_equal Time.local(2006, 4, 1), time.end
+
+    time = quarter.next(:past)
+    assert_equal Time.local(2005, 1, 1), time.begin
+    assert_equal Time.local(2005, 4, 1), time.end
+
+    quarter = Chronic::RepeaterQuarterName.new(:q2)
+    quarter.start = @now
+
+    time = quarter.next(:past)
+    assert_equal Time.local(2006, 4, 1), time.begin
+    assert_equal Time.local(2006, 7, 1), time.end
+
+    time = quarter.next(:past)
+    assert_equal Time.local(2005, 4, 1), time.begin
+    assert_equal Time.local(2005, 7, 1), time.end
+
+    quarter = Chronic::RepeaterQuarterName.new(:q3)
+    quarter.start = @now
+
+    time = quarter.next(:past)
+    assert_equal Time.local(2005, 7, 1), time.begin
+    assert_equal Time.local(2005, 10, 1), time.end
+
+    time = quarter.next(:past)
+    assert_equal Time.local(2004, 7, 1), time.begin
+    assert_equal Time.local(2004, 10, 1), time.end
+
+    quarter = Chronic::RepeaterQuarterName.new(:q4)
+    quarter.start = @now
+
+    time = quarter.next(:past)
+    assert_equal Time.local(2005, 10, 1), time.begin
+    assert_equal Time.local(2006, 1, 1), time.end
+
+    time = quarter.next(:past)
+    assert_equal Time.local(2004, 10, 1), time.begin
+    assert_equal Time.local(2005, 1, 1), time.end
+  end
+end
diff --git a/test/test_RepeaterSeason.rb b/test/test_repeater_season.rb
similarity index 95%
rename from test/test_RepeaterSeason.rb
rename to test/test_repeater_season.rb
index 20838942..e76fa72c 100644
--- a/test/test_RepeaterSeason.rb
+++ b/test/test_repeater_season.rb
@@ -1,6 +1,6 @@
 require 'helper'
 
-class TestRepeaterSeason < Test::Unit::TestCase
+class TestRepeaterSeason < TestCase
 
   def setup
     @now = Time.local(2006, 8, 16, 14, 0, 0, 0)
diff --git a/test/test_RepeaterTime.rb b/test/test_repeater_time.rb
similarity index 76%
rename from test/test_RepeaterTime.rb
rename to test/test_repeater_time.rb
index 5572c930..26b2bcb3 100644
--- a/test/test_RepeaterTime.rb
+++ b/test/test_repeater_time.rb
@@ -1,12 +1,18 @@
 require 'helper'
 
-class TestRepeaterTime < Test::Unit::TestCase
+class TestRepeaterTime < TestCase
 
   def setup
     # Wed Aug 16 14:00:00 2006
     @now = Time.local(2006, 8, 16, 14, 0, 0, 0)
   end
 
+  def test_generic
+    assert_raises(ArgumentError) do
+      Chronic::RepeaterTime.new('00:01:02:03:004')
+    end
+  end
+
   def test_next_future
     t = Chronic::RepeaterTime.new('4:00')
     t.start = @now
@@ -25,6 +31,12 @@ def test_next_future
 
     assert_equal Time.local(2006, 8, 17, 4), t.next(:future).begin
     assert_equal Time.local(2006, 8, 18, 4), t.next(:future).begin
+
+    t = Chronic::RepeaterTime.new('0000')
+    t.start = @now
+
+    assert_equal Time.local(2006, 8, 17, 0), t.next(:future).begin
+    assert_equal Time.local(2006, 8, 18, 0), t.next(:future).begin
   end
 
   def test_next_past
@@ -39,6 +51,12 @@ def test_next_past
 
     assert_equal Time.local(2006, 8, 16, 13), t.next(:past).begin
     assert_equal Time.local(2006, 8, 15, 13), t.next(:past).begin
+
+    t = Chronic::RepeaterTime.new('0:00.000')
+    t.start = @now
+
+    assert_equal Time.local(2006, 8, 16, 0), t.next(:past).begin
+    assert_equal Time.local(2006, 8, 15, 0), t.next(:past).begin
   end
 
   def test_type
diff --git a/test/test_repeater_week.rb b/test/test_repeater_week.rb
new file mode 100644
index 00000000..a1767020
--- /dev/null
+++ b/test/test_repeater_week.rb
@@ -0,0 +1,115 @@
+require 'helper'
+
+class TestRepeaterWeek < TestCase
+
+  def setup
+    @now = Time.local(2006, 8, 16, 14, 0, 0, 0)
+  end
+
+  def test_next_future
+    weeks = Chronic::RepeaterWeek.new(:week)
+    weeks.start = @now
+
+    next_week = weeks.next(:future)
+    assert_equal Time.local(2006, 8, 20), next_week.begin
+    assert_equal Time.local(2006, 8, 27), next_week.end
+
+    next_next_week = weeks.next(:future)
+    assert_equal Time.local(2006, 8, 27), next_next_week.begin
+    assert_equal Time.local(2006, 9, 3), next_next_week.end
+  end
+
+  def test_next_past
+    weeks = Chronic::RepeaterWeek.new(:week)
+    weeks.start = @now
+
+    last_week = weeks.next(:past)
+    assert_equal Time.local(2006, 8, 6), last_week.begin
+    assert_equal Time.local(2006, 8, 13), last_week.end
+
+    last_last_week = weeks.next(:past)
+    assert_equal Time.local(2006, 7, 30), last_last_week.begin
+    assert_equal Time.local(2006, 8, 6), last_last_week.end
+  end
+
+  def test_this_future
+    weeks = Chronic::RepeaterWeek.new(:week)
+    weeks.start = @now
+
+    this_week = weeks.this(:future)
+    assert_equal Time.local(2006, 8, 16, 15), this_week.begin
+    assert_equal Time.local(2006, 8, 20), this_week.end
+  end
+
+  def test_this_past
+    weeks = Chronic::RepeaterWeek.new(:week)
+    weeks.start = @now
+
+    this_week = weeks.this(:past)
+    assert_equal Time.local(2006, 8, 13, 0), this_week.begin
+    assert_equal Time.local(2006, 8, 16, 14), this_week.end
+  end
+
+  def test_offset
+    span = Chronic::Span.new(@now, @now + 1)
+
+    offset_span = Chronic::RepeaterWeek.new(:week).offset(span, 3, :future)
+
+    assert_equal Time.local(2006, 9, 6, 14), offset_span.begin
+    assert_equal Time.local(2006, 9, 6, 14, 0, 1), offset_span.end
+  end
+
+  def test_next_future_starting_on_monday
+    weeks = Chronic::RepeaterWeek.new(:week, nil, :week_start => :monday)
+    weeks.start = @now
+
+    next_week = weeks.next(:future)
+    assert_equal Time.local(2006, 8, 21), next_week.begin
+    assert_equal Time.local(2006, 8, 28), next_week.end
+
+    next_next_week = weeks.next(:future)
+    assert_equal Time.local(2006, 8, 28), next_next_week.begin
+    assert_equal Time.local(2006, 9, 4), next_next_week.end
+  end
+
+  def test_next_past_starting_on_monday
+    weeks = Chronic::RepeaterWeek.new(:week, nil, :week_start => :monday)
+    weeks.start = @now
+
+    last_week = weeks.next(:past)
+    assert_equal Time.local(2006, 8, 7), last_week.begin
+    assert_equal Time.local(2006, 8, 14), last_week.end
+
+    last_last_week = weeks.next(:past)
+    assert_equal Time.local(2006, 7, 31), last_last_week.begin
+    assert_equal Time.local(2006, 8, 7), last_last_week.end
+  end
+
+  def test_this_future_starting_on_monday
+    weeks = Chronic::RepeaterWeek.new(:week, nil, :week_start => :monday)
+    weeks.start = @now
+
+    this_week = weeks.this(:future)
+    assert_equal Time.local(2006, 8, 16, 15), this_week.begin
+    assert_equal Time.local(2006, 8, 21), this_week.end
+  end
+
+  def test_this_past_starting_on_monday
+    weeks = Chronic::RepeaterWeek.new(:week, nil, :week_start => :monday)
+    weeks.start = @now
+
+    this_week = weeks.this(:past)
+    assert_equal Time.local(2006, 8, 14, 0), this_week.begin
+    assert_equal Time.local(2006, 8, 16, 14), this_week.end
+  end
+
+  def test_offset_starting_on_monday
+    weeks = Chronic::RepeaterWeek.new(:week, nil, :week_start => :monday)
+
+    span = Chronic::Span.new(@now, @now + 1)
+    offset_span = weeks.offset(span, 3, :future)
+
+    assert_equal Time.local(2006, 9, 6, 14), offset_span.begin
+    assert_equal Time.local(2006, 9, 6, 14, 0, 1), offset_span.end
+  end
+end
diff --git a/test/test_RepeaterWeekday.rb b/test/test_repeater_weekday.rb
similarity index 97%
rename from test/test_RepeaterWeekday.rb
rename to test/test_repeater_weekday.rb
index 8f2f5b3e..af981256 100644
--- a/test/test_RepeaterWeekday.rb
+++ b/test/test_repeater_weekday.rb
@@ -1,6 +1,6 @@
 require 'helper'
 
-class TestRepeaterWeekday < Test::Unit::TestCase
+class TestRepeaterWeekday < TestCase
 
   def setup
     @now = Time.local(2007, 6, 11, 14, 0, 0, 0) # Mon
diff --git a/test/test_RepeaterWeekend.rb b/test/test_repeater_weekend.rb
similarity index 97%
rename from test/test_RepeaterWeekend.rb
rename to test/test_repeater_weekend.rb
index c0d471ad..8727c5de 100644
--- a/test/test_RepeaterWeekend.rb
+++ b/test/test_repeater_weekend.rb
@@ -1,6 +1,6 @@
 require 'helper'
 
-class TestRepeaterWeekend < Test::Unit::TestCase
+class TestRepeaterWeekend < TestCase
 
   def setup
     # Wed Aug 16 14:00:00 2006
diff --git a/test/test_RepeaterYear.rb b/test/test_repeater_year.rb
similarity index 97%
rename from test/test_RepeaterYear.rb
rename to test/test_repeater_year.rb
index 9cef1701..916ef04c 100644
--- a/test/test_RepeaterYear.rb
+++ b/test/test_repeater_year.rb
@@ -1,6 +1,6 @@
 require 'helper'
 
-class TestRepeaterYear < Test::Unit::TestCase
+class TestRepeaterYear < TestCase
 
   def setup
     @now = Time.local(2006, 8, 16, 14, 0, 0, 0)
diff --git a/test/test_Span.rb b/test/test_span.rb
similarity index 84%
rename from test/test_Span.rb
rename to test/test_span.rb
index 0271233a..3bd099f6 100644
--- a/test/test_Span.rb
+++ b/test/test_span.rb
@@ -1,6 +1,6 @@
 require 'helper'
 
-class TestSpan < Test::Unit::TestCase
+class TestSpan < TestCase
 
   def setup
     # Wed Aug 16 14:00:00 UTC 2006
@@ -9,7 +9,7 @@ def setup
 
   def test_span_width
     span = Chronic::Span.new(Time.local(2006, 8, 16, 0), Time.local(2006, 8, 17, 0))
-    assert_equal (60 * 60 * 24), span.width
+    assert_equal((60 * 60 * 24), span.width)
   end
 
   def test_span_math
diff --git a/test/test_Token.rb b/test/test_token.rb
similarity index 75%
rename from test/test_Token.rb
rename to test/test_token.rb
index 78802d1b..cf278675 100644
--- a/test/test_Token.rb
+++ b/test/test_token.rb
@@ -1,6 +1,6 @@
 require 'helper'
 
-class TestToken < Test::Unit::TestCase
+class TestToken < TestCase
 
   def setup
     # Wed Aug 16 14:00:00 UTC 2006
@@ -22,4 +22,10 @@ def test_token
     assert_equal 'foo', token.word
   end
 
+  def test_token_inspect_doesnt_mutate_the_word
+    token = Chronic::Token.new('foo')
+    token.inspect
+    assert_equal 'foo', token.word
+  end
+
 end