chronic 0.2.2 → 0.10.2

data/lib/chronic.rb

@@ -1,16 +1,25 @@
-#=============================================================================
-#
-#  Name:       Chronic
-#  Author:     Tom Preston-Werner
-#  Purpose:    Parse natural language dates and times into Time or
-#              Chronic::Span objects
-#
-#=============================================================================
+require 'time'
+require 'date'
 
-$:.unshift File.dirname(__FILE__)     # For use/testing when no gem is installed
+require 'chronic/parser'
+require 'chronic/date'
+require 'chronic/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/sign'
+require 'chronic/time_zone'
+require 'chronic/numerizer'
+require 'chronic/season'
 
 require 'chronic/repeater'
 require 'chronic/repeaters/repeater_year'
@@ -21,6 +30,7 @@ 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'
@@ -29,87 +39,95 @@ require 'chronic/repeaters/repeater_minute'
 require 'chronic/repeaters/repeater_second'
 require 'chronic/repeaters/repeater_time'
 
-require 'chronic/grabber'
-require 'chronic/pointer'
-require 'chronic/scalar'
-require 'chronic/ordinal'
-require 'chronic/separator'
-require 'chronic/time_zone'
+# Parse natural language dates and times into Time or Chronic::Span objects.
+#
+# Examples:
+#
+#   require 'chronic'
+#
+#   Time.now   #=> Sun Aug 27 23:18:25 PDT 2006
+#
+#   Chronic.parse('tomorrow')
+#     #=> Mon Aug 28 12:00:00 PDT 2006
+#
+#   Chronic.parse('monday', :context => :past)
+#     #=> Mon Aug 21 12:00:00 PDT 2006
+module Chronic
+  VERSION = "0.10.2"
 
-require 'numerizer/numerizer'
+  class << self
 
-module Chronic
-  VERSION = "0.2.2"
-  
-  def self.debug; false; end
-end
+    # Returns true when debug mode is enabled.
+    attr_accessor :debug
 
-alias p_orig p
+    # Examples:
+    #
+    #   require 'chronic'
+    #   require 'active_support/time'
+    #
+    #   Time.zone = 'UTC'
+    #   Chronic.time_class = Time.zone
+    #   Chronic.parse('June 15 2006 at 5:54 AM')
+    #     # => Thu, 15 Jun 2006 05:45:00 UTC +00:00
+    #
+    # Returns The Time class Chronic uses internally.
+    attr_accessor :time_class
+  end
 
-def p(val)
-  p_orig val
-  puts
-end
+  self.debug = false
+  self.time_class = ::Time
 
-# class Time
-#   def self.construct(year, month = 1, day = 1, hour = 0, minute = 0, second = 0)
-#     # extra_seconds = second > 60 ? second - 60 : 0
-#     # extra_minutes = minute > 59 ? minute - 59 : 0
-#     # extra_hours = hour > 23 ? hour - 23 : 0
-#     # extra_days = day > 
-#     
-#     if month > 12
-#       if month % 12 == 0
-#         year += (month - 12) / 12
-#         month = 12
-#       else
-#         year += month / 12
-#         month = month % 12
-#       end
-#     end
-#     
-#     base = Time.local(year, month)
-#     puts base
-#     offset = ((day - 1) * 24 * 60 * 60) + (hour * 60 * 60) + (minute * 60) + second
-#     puts offset.to_s
-#     date = base + offset
-#     puts date
-#     date
-#   end
-# end
-
-class Time
-  def self.construct(year, month = 1, day = 1, hour = 0, minute = 0, second = 0)
+
+  # 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
+
+  # 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
-      leap_year = (year % 4 == 0) && !(year % 100 == 0)
-      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 = leap_year ? leap_year_month_days[month - 1] : common_year_month_days[month - 1]
+    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
@@ -119,7 +137,14 @@ class Time
         month = month % 12
       end
     end
-    
-    Time.local(year, month, day, hour, minute, second)
+    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
+
+end

data/test/helper.rb

@@ -0,0 +1,12 @@
+unless defined? Chronic
+  $:.unshift File.expand_path('../../lib', __FILE__)
+  require 'chronic'
+end
+
+require 'minitest/autorun'
+
+class TestCase < MiniTest::Test
+  def self.test(name, &block)
+    define_method("test_#{name.gsub(/\W/, '_')}", &block) if block
+  end
+end

data/test/test_chronic.rb

@@ -0,0 +1,183 @@
+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 Chronic::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)
+    ]
+
+    assert_equal endians, Chronic::Parser.new.definitions[:endian]
+
+    defs = Chronic::Parser.new.definitions(:endian_precedence => :little)
+    assert_equal endians.reverse, defs[:endian]
+
+    defs = Chronic::Parser.new.definitions(:endian_precedence => [:little, :middle])
+    assert_equal endians.reverse, defs[:endian]
+
+    assert_raises(ArgumentError) do
+      Chronic::Parser.new.definitions(:endian_precedence => :invalid)
+    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_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

data/test/test_daylight_savings.rb

@@ -0,0 +1,118 @@
+require 'helper'
+
+class TestDaylightSavings < TestCase
+
+  def setup
+    @begin_daylight_savings = Time.local(2008, 3, 9, 5, 0, 0, 0)
+    @end_daylight_savings = Time.local(2008, 11, 2, 5, 0, 0, 0)
+  end
+
+  def test_begin_past
+    # ambiguous - resolve to last night
+    t = Chronic::RepeaterTime.new('900')
+    t.start = @begin_daylight_savings
+    assert_equal Time.local(2008, 3, 8, 21), t.next(:past).begin
+
+    # ambiguous - resolve to this afternoon
+    t = Chronic::RepeaterTime.new('900')
+    t.start = Time.local(2008, 3, 9, 22, 0, 0, 0)
+    assert_equal Time.local(2008, 3, 9, 21), t.next(:past).begin
+
+    # ambiguous - resolve to this morning
+    t = Chronic::RepeaterTime.new('400')
+    t.start = @begin_daylight_savings
+    assert_equal Time.local(2008, 3, 9, 4), t.next(:past).begin
+
+    # unambiguous - resolve to today
+    t = Chronic::RepeaterTime.new('0400')
+    t.start = @begin_daylight_savings
+    assert_equal Time.local(2008, 3, 9, 4), t.next(:past).begin
+
+    # unambiguous - resolve to yesterday
+    t = Chronic::RepeaterTime.new('1300')
+    t.start = @begin_daylight_savings
+    assert_equal Time.local(2008, 3, 8, 13), t.next(:past).begin
+  end
+
+  def test_begin_future
+    # ambiguous - resolve to this morning
+    t = Chronic::RepeaterTime.new('900')
+    t.start = @begin_daylight_savings
+    assert_equal Time.local(2008, 3, 9, 9), t.next(:future).begin
+
+    # ambiguous - resolve to this afternoon
+    t = Chronic::RepeaterTime.new('900')
+    t.start = Time.local(2008, 3, 9, 13, 0, 0, 0)
+    assert_equal Time.local(2008, 3, 9, 21), t.next(:future).begin
+
+    # ambiguous - resolve to tomorrow
+    t = Chronic::RepeaterTime.new('900')
+    t.start = Time.local(2008, 3, 9, 22, 0, 0, 0)
+    assert_equal Time.local(2008, 3, 10, 9), t.next(:future).begin
+
+    # unambiguous - resolve to today
+    t = Chronic::RepeaterTime.new('0900')
+    t.start = @begin_daylight_savings
+    assert_equal Time.local(2008, 3, 9, 9), t.next(:future).begin
+
+    # unambiguous - resolve to tomorrow
+    t = Chronic::RepeaterTime.new('0400')
+    t.start = @begin_daylight_savings
+    assert_equal Time.local(2008, 3, 10, 4), t.next(:future).begin
+  end
+
+  def test_end_past
+    # ambiguous - resolve to last night
+    t = Chronic::RepeaterTime.new('900')
+    t.start = @end_daylight_savings
+    assert_equal Time.local(2008, 11, 1, 21), t.next(:past).begin
+
+    # ambiguous - resolve to this afternoon
+    t = Chronic::RepeaterTime.new('900')
+    t.start = Time.local(2008, 11, 2, 22, 0, 0, 0)
+    assert_equal Time.local(2008, 11, 2, 21), t.next(:past).begin
+
+    # ambiguous - resolve to this morning
+    t = Chronic::RepeaterTime.new('400')
+    t.start = @end_daylight_savings
+    assert_equal Time.local(2008, 11, 2, 4), t.next(:past).begin
+
+    # unambiguous - resolve to today
+    t = Chronic::RepeaterTime.new('0400')
+    t.start = @end_daylight_savings
+    assert_equal Time.local(2008, 11, 2, 4), t.next(:past).begin
+
+    # unambiguous - resolve to yesterday
+    t = Chronic::RepeaterTime.new('1300')
+    t.start = @end_daylight_savings
+    assert_equal Time.local(2008, 11, 1, 13), t.next(:past).begin
+  end
+
+  def test_end_future
+    # ambiguous - resolve to this morning
+    t = Chronic::RepeaterTime.new('900')
+    t.start = @end_daylight_savings
+    assert_equal Time.local(2008, 11, 2, 9), t.next(:future).begin
+
+    # ambiguous - resolve to this afternoon
+    t = Chronic::RepeaterTime.new('900')
+    t.start = Time.local(2008, 11, 2, 13, 0, 0, 0)
+    assert_equal Time.local(2008, 11, 2, 21), t.next(:future).begin
+
+    # ambiguous - resolve to tomorrow
+    t = Chronic::RepeaterTime.new('900')
+    t.start = Time.local(2008, 11, 2, 22, 0, 0, 0)
+    assert_equal Time.local(2008, 11, 3, 9), t.next(:future).begin
+
+    # unambiguous - resolve to today
+    t = Chronic::RepeaterTime.new('0900')
+    t.start = @end_daylight_savings
+    assert_equal Time.local(2008, 11, 2, 9), t.next(:future).begin
+
+    # unambiguous - resolve to tomorrow
+    t = Chronic::RepeaterTime.new('0400')
+    t.start = @end_daylight_savings
+    assert_equal Time.local(2008, 11, 3, 4), t.next(:future).begin
+  end
+
+end