chronic 0.8.0 → 0.9.1

data/lib/chronic/{chronic.rb → parser.rb}

@@ -1,25 +1,23 @@
-module Chronic
-
-  # Returns a Hash of default configuration options.
-  DEFAULT_OPTIONS = {
-    :context => :future,
-    :now => nil,
-    :guess => true,
-    :ambiguous_time_range => 6,
-    :endian_precedence    => [:middle, :little],
-    :ambiguous_year_future_bias => 50
-  }
+require 'chronic/handlers'
 
-  class << self
+module Chronic
+  class Parser
+    include Handlers
+
+    # Hash of default configuration options.
+    DEFAULT_OPTIONS = {
+      :context => :future,
+      :now => nil,
+      :guess => true,
+      :ambiguous_time_range => 6,
+      :endian_precedence    => [:middle, :little],
+      :ambiguous_year_future_bias => 50
+    }
+
+    attr_accessor :now
+    attr_reader :options
 
-    # 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:
+    # 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.
@@ -47,31 +45,18 @@ module Chronic
     #                 look x amount of years into the future and past. If the
     #                 two digit year is `now + x years` it's assumed to be the
     #                 future, `now - x years` is assumed to be the past.
-    #
-    # Returns a new Time object, or Chronic::Span if :guess option is false.
-    def parse(text, opts={})
-      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
+    def initialize(options = {})
+      @options = DEFAULT_OPTIONS.merge(options)
+      @now = options.delete(:now) || Chronic.time_class.now
+    end
 
-      # tokenize words
+    # 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))
 
-      if Chronic.debug
-        puts "+#{'-' * 51}\n| #{tokens}\n+#{'-' * 51}"
-      end
-
-      span = tokens_to_span(tokens, options)
+      puts "+#{'-' * 51}\n| #{tokens}\n+#{'-' * 51}" if Chronic.debug
 
       if span
         options[:guess] ? guess(span) : span
@@ -101,13 +86,14 @@ module Chronic
     # Returns a new String ready for Chronic to parse.
     def pre_normalize(text)
       text = text.to_s.downcase
+      text.gsub!(/\b([ap])\.m\.?/, '\1m')
       text.gsub!(/\./, ':')
       text.gsub!(/['"]/, '')
       text.gsub!(/,/, ' ')
       text.gsub!(/^second /, '2nd ')
       text.gsub!(/\bsecond (of|day|month|hour|minute|second)\b/, '2nd \1')
       text = Numerizer.numerize(text)
-      text.gsub!(/ \-(\d{4})\b/, ' tzminus\1')
+      text.gsub!(/\-(\d{2}:?\d{2})\b/, 'tzminus\1')
       text.gsub!(/([\/\-\,\@])/) { ' ' + $1 + ' ' }
       text.gsub!(/(?:^|\s)0(\d+:\d+\s*pm?\b)/, ' \1')
       text.gsub!(/\btoday\b/, 'this day')
@@ -116,29 +102,25 @@ module Chronic
       text.gsub!(/\bnoon\b/, '12:00pm')
       text.gsub!(/\bmidnight\b/, '24:00')
       text.gsub!(/\bnow\b/, 'this second')
+      text.gsub!('quarter', '15')
+      text.gsub!('half', '30')
+      text.gsub!(/(\d{1,2}) (to|till|prior to|before)\b/, '\1 minutes past')
+      text.gsub!(/(\d{1,2}) (after|past)\b/, '\1 minutes future')
       text.gsub!(/\b(?:ago|before(?: now)?)\b/, 'past')
       text.gsub!(/\bthis (?:last|past)\b/, 'last')
       text.gsub!(/\b(?:in|during) the (morning)\b/, '\1')
       text.gsub!(/\b(?:in the|during the|at) (afternoon|evening|night)\b/, '\1')
       text.gsub!(/\btonight\b/, 'this night')
       text.gsub!(/\b\d+:?\d*[ap]\b/,'\0m')
+      text.gsub!(/\b(\d{2})(\d{2})(am|pm)\b/, '\1:\2\3')
       text.gsub!(/(\d)([ap]m|oclock)\b/, '\1 \2')
       text.gsub!(/\b(hence|after|from)\b/, 'future')
       text.gsub!(/^\s?an? /i, '1 ')
       text.gsub!(/\b(\d{4}):(\d{2}):(\d{2})\b/, '\1 / \2 / \3') # DTOriginal
+      text.gsub!(/\b0(\d+):(\d{2}):(\d{2}) ([ap]m)\b/, '\1:\2:\3 \4')
       text
     end
 
-    # Convert number words to numbers (three => 3, fourth => 4th).
-    #
-    # text - The String to convert.
-    #
-    # Returns a new String with words converted to numbers.
-    def numericize_numbers(text)
-      warn "Chronic.numericize_numbers will be deprecated in version 0.7.0. Please use Chronic::Numerizer.numerize instead"
-      Numerizer.numerize(text)
-    end
-
     # Guess a specific time within the given span.
     #
     # span - The Chronic::Span object to calcuate a guess from.
@@ -152,17 +134,16 @@ module Chronic
       end
     end
 
-    # List of Handler definitions. See #parse for a list of options this
+    # List of Handler definitions. See Chronic.parse for a list of options this
     # method accepts.
     #
-    # options - An optional Hash of configuration options:
-    #           :endian_precedence -
+    # options - An optional Hash of configuration options.
     #
-    # Returns A Hash of Handler definitions.
-    def definitions(options={})
+    # Returns a Hash of Handler definitions.
+    def definitions(options = {})
       options[:endian_precedence] ||= [:middle, :little]
 
-      @definitions ||= {
+      @@definitions ||= {
         :time => [
           Handler.new([:repeater_time, :repeater_day_portion?], nil)
         ],
@@ -172,12 +153,15 @@ module Chronic
           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, :scalar_day, :separator_at?, 'time?'], :handle_rdn_rmn_sd),
+          Handler.new([:repeater_day_name, :repeater_month_name, :ordinal_day, :separator_at?, 'time?'], :handle_rdn_rmn_od),
+          Handler.new([:repeater_day_name, :ordinal_day, :separator_at?, 'time?'], :handle_rdn_od),
           Handler.new([:scalar_year, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :scalar_day, :repeater_time, :time_zone], :handle_generic),
           Handler.new([: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_month_name, :separator_slash_or_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),
@@ -187,29 +171,27 @@ module Chronic
           Handler.new([:repeater_time, :repeater_day_portion?, :separator_on?, :repeater_month_name, :ordinal_day], :handle_rmn_od_on),
           Handler.new([:repeater_month_name, :scalar_year], :handle_rmn_sy),
           Handler.new([:scalar_day, :repeater_month_name, :scalar_year, :separator_at?, 'time?'], :handle_sd_rmn_sy),
-          Handler.new([:scalar_day, :repeater_month_name, :separator_at?, 'time?'], :handle_sd_rmn),
+          Handler.new([:scalar_day, :separator_slash_or_dash?, :repeater_month_name, :separator_at?, 'time?'], :handle_sd_rmn),
           Handler.new([:scalar_year, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :scalar_day, :separator_at?, 'time?'], :handle_sy_sm_sd),
+          Handler.new([:scalar_year, :separator_slash_or_dash, :scalar_month], :handle_sy_sm),
           Handler.new([:scalar_month, :separator_slash_or_dash, :scalar_year], :handle_sm_sy),
           Handler.new([:scalar_day, :separator_slash_or_dash, :repeater_month_name, :separator_slash_or_dash, :scalar_year, :repeater_time?], :handle_sm_rmn_sy),
-          Handler.new([:scalar_year, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :time_zone], :handle_generic)
-
+          Handler.new([:scalar_year, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :scalar?, :time_zone], :handle_generic),
         ],
 
-        # tonight at 7pm
         :anchor => [
           Handler.new([:separator_on?, :grabber?, :repeater, :separator_at?, :repeater?, :repeater?], :handle_r),
           Handler.new([:grabber?, :repeater, :repeater, :separator?, :repeater?, :repeater?], :handle_r),
           Handler.new([:repeater, :grabber, :repeater], :handle_r_g_r)
         ],
 
-        # 3 weeks from now, in 2 months
         :arrow => [
           Handler.new([:scalar, :repeater, :pointer], :handle_s_r_p),
+          Handler.new([:scalar, :repeater, :separator_and?, :scalar, :repeater, :pointer, :separator_at?, 'anchor'], :handle_s_r_a_s_r_p_a),
           Handler.new([:pointer, :scalar, :repeater], :handle_p_s_r),
           Handler.new([:scalar, :repeater, :pointer, :separator_at?, 'anchor'], :handle_s_r_p_a)
         ],
 
-        # 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)
@@ -225,68 +207,12 @@ module Chronic
 
       case endian = Array(options[:endian_precedence]).first
       when :little
-        @definitions[:endian] = endians.reverse
+        @@definitions.merge(:endian => endians.reverse)
       when :middle
-        @definitions[:endian] = endians
+        @@definitions.merge(:endian => endians)
       else
         raise ArgumentError, "Unknown endian option '#{endian}'"
       end
-
-      @definitions
-    end
-
-    # Construct a new time object determining possible month overflows
-    # and leap years.
-    #
-    # year   - Integer year.
-    # month  - Integer month.
-    # day    - Integer day.
-    # hour   - Integer hour.
-    # minute - Integer minute.
-    # second - Integer second.
-    #
-    # Returns a new Time object constructed from these params.
-    def construct(year, month = 1, day = 1, hour = 0, minute = 0, second = 0)
-      if second >= 60
-        minute += second / 60
-        second = second % 60
-      end
-
-      if minute >= 60
-        hour += minute / 60
-        minute = minute % 60
-      end
-
-      if hour >= 24
-        day += hour / 24
-        hour = hour % 24
-      end
-
-      # determine if there is a day overflow. this is complicated by our crappy calendar
-      # system (non-constant number of days per month)
-      day <= 56 || raise("day must be no more than 56 (makes month resolution easier)")
-      if day > 28
-        # no month ever has fewer than 28 days, so only do this if necessary
-        leap_year_month_days = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
-        common_year_month_days = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
-        days_this_month = Date.leap?(year) ? leap_year_month_days[month - 1] : common_year_month_days[month - 1]
-        if day > days_this_month
-          month += day / days_this_month
-          day = day % days_this_month
-        end
-      end
-
-      if month > 12
-        if month % 12 == 0
-          year += (month - 12) / 12
-          month = 12
-        else
-          year += month / 12
-          month = month % 12
-        end
-      end
-
-      Chronic.time_class.local(year, month, day, hour, minute, second)
     end
 
     private
@@ -306,37 +232,32 @@ module Chronic
       (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)
+          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, options)
+          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(SeparatorSlashOrDash) || o.get_tag(SeparatorComma) }
-          return handler.invoke(:arrow, good_tokens, options)
+          good_tokens = tokens.reject { |o| o.get_tag(SeparatorAt) || o.get_tag(SeparatorSlashOrDash) || 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, options)
+          return handler.invoke(:narrow, tokens, self, options)
         end
       end
 
       puts "-none" if Chronic.debug
       return nil
     end
-
-  end
-
-  # Internal exception
-  class ChronicPain < Exception
   end
 end

data/lib/chronic/repeater.rb

@@ -38,18 +38,18 @@ module Chronic
     def self.scan_for_month_names(token)
       scan_for token, RepeaterMonthName,
       {
-        /^jan\.?(uary)?$/ => :january,
-        /^feb\.?(ruary)?$/ => :february,
-        /^mar\.?(ch)?$/ => :march,
-        /^apr\.?(il)?$/ => :april,
+        /^jan[:\.]?(uary)?$/ => :january,
+        /^feb[:\.]?(ruary)?$/ => :february,
+        /^mar[:\.]?(ch)?$/ => :march,
+        /^apr[:\.]?(il)?$/ => :april,
         /^may$/ => :may,
-        /^jun\.?e?$/ => :june,
-        /^jul\.?y?$/ => :july,
-        /^aug\.?(ust)?$/ => :august,
-        /^sep\.?(t\.?|tember)?$/ => :september,
-        /^oct\.?(ober)?$/ => :october,
-        /^nov\.?(ember)?$/ => :november,
-        /^dec\.?(ember)?$/ => :december
+        /^jun[:\.]?e?$/ => :june,
+        /^jul[:\.]?y?$/ => :july,
+        /^aug[:\.]?(ust)?$/ => :august,
+        /^sep[:\.]?(t[:\.]?|tember)?$/ => :september,
+        /^oct[:\.]?(ober)?$/ => :october,
+        /^nov[:\.]?(ember)?$/ => :november,
+        /^dec[:\.]?(ember)?$/ => :december
       }
     end
 

data/lib/chronic/separator.rb

@@ -15,6 +15,7 @@ module Chronic
         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
+        if t = scan_for_and(token) then token.tag(t); next end
       end
     end
 
@@ -57,6 +58,13 @@ module Chronic
       scan_for token, SeparatorOn, { /^on$/ => :on }
     end
 
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeperatorAnd Object object.
+    def self.scan_for_and(token)
+      scan_for token, SeparatorAnd, { /^and$/ => :and }
+    end
+
     def to_s
       'separator'
     end
@@ -91,4 +99,10 @@ module Chronic
       super << '-on'
     end
   end
-end
+
+  class SeparatorAnd < Separator #:nodoc:
+    def to_s
+      super << '-and'
+    end
+  end
+end

data/lib/chronic/span.rb

@@ -25,7 +25,7 @@ module Chronic
       '(' << 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
+end

data/lib/chronic/token.rb

@@ -43,5 +43,9 @@ module Chronic
     def to_s
       @word << '(' << @tags.join(', ') << ') '
     end
+
+    def inspect
+      to_s
+    end
   end
 end

data/lib/chronic.rb

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

data/test/test_chronic.rb

@@ -8,12 +8,12 @@ class TestChronic < TestCase
   end
 
   def test_pre_normalize
-    assert_equal Chronic.pre_normalize('12:55 pm'), Chronic.pre_normalize('12.55 pm')
+    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 Chronic::Numerizer.numerize(string), Chronic.pre_normalize(string)
+    assert_equal Chronic::Numerizer.numerize(string), Chronic::Parser.new.pre_normalize(string)
   end
 
   def test_post_normalize_am_pm_aliases
@@ -46,21 +46,13 @@ class TestChronic < TestCase
 
   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)
+    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.guess(span)
+    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.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
+    assert_equal Time.local(2006, 11, 16), Chronic::Parser.new.guess(span)
   end
 
   def test_endian_definitions
@@ -72,26 +64,16 @@ class TestChronic < TestCase
       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]
+    assert_equal endians, Chronic::Parser.new.definitions[:endian]
 
-    defs = Chronic.definitions(:endian_precedence => :little)
+    defs = Chronic::Parser.new.definitions(:endian_precedence => :little)
     assert_equal endians.reverse, defs[:endian]
 
-    defs = Chronic.definitions(:endian_precedence => [:little, :middle])
+    defs = Chronic::Parser.new.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)
+      Chronic::Parser.new.definitions(:endian_precedence => :invalid)
     end
   end