chronic 0.9.0 → 0.10.2

data/lib/chronic/separator.rb

@@ -11,11 +11,18 @@ module Chronic
     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_dots(token) then token.tag(t); next end
+        if t = scan_for_colon(token) then token.tag(t); next end
+        if t = scan_for_space(token) then token.tag(t); next end
+        if t = scan_for_slash(token) then token.tag(t); next end
+        if t = scan_for_dash(token) then token.tag(t); next end
+        if t = scan_for_quote(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
         if t = scan_for_and(token) then token.tag(t); next end
+        if t = scan_for_t(token) then token.tag(t); next end
+        if t = scan_for_w(token) then token.tag(t); next end
       end
     end
 
@@ -28,12 +35,47 @@ module Chronic
 
     # token - The Token object we want to scan.
     #
-    # Returns a new SeparatorSlashOrDash object.
-    def self.scan_for_slash_or_dash(token)
-      scan_for token, SeparatorSlashOrDash,
+    # Returns a new SeparatorDot object.
+    def self.scan_for_dots(token)
+      scan_for token, SeparatorDot, { /^\.$/ => :dot }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorColon object.
+    def self.scan_for_colon(token)
+      scan_for token, SeparatorColon, { /^:$/ => :colon }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorSpace object.
+    def self.scan_for_space(token)
+      scan_for token, SeparatorSpace, { /^ $/ => :space }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorSlash object.
+    def self.scan_for_slash(token)
+      scan_for token, SeparatorSlash, { /^\/$/ => :slash }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorDash object.
+    def self.scan_for_dash(token)
+      scan_for token, SeparatorDash, { /^-$/ => :dash }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeparatorQuote object.
+    def self.scan_for_quote(token)
+      scan_for token, SeparatorQuote,
       {
-        /^-$/ => :dash,
-        /^\/$/ => :slash
+        /^'$/ => :single_quote,
+        /^"$/ => :double_quote
       }
     end
 
@@ -65,6 +107,20 @@ module Chronic
       scan_for token, SeparatorAnd, { /^and$/ => :and }
     end
 
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeperatorT Object object.
+    def self.scan_for_t(token)
+      scan_for token, SeparatorT, { /^t$/ => :T }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SeperatorW Object object.
+    def self.scan_for_w(token)
+      scan_for token, SeparatorW, { /^w$/ => :W }
+    end
+
     def to_s
       'separator'
     end
@@ -76,9 +132,39 @@ module Chronic
     end
   end
 
-  class SeparatorSlashOrDash < Separator #:nodoc:
+  class SeparatorDot < Separator #:nodoc:
     def to_s
-      super << '-slashordash-' << @type.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
 
@@ -105,4 +191,17 @@ module Chronic
       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

data/lib/chronic/sign.rb

@@ -0,0 +1,49 @@
+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|
+        if t = scan_for_plus(token) then token.tag(t); next end
+        if t = scan_for_minus(token) then token.tag(t); next end
+      end
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SignPlus object.
+    def self.scan_for_plus(token)
+      scan_for token, SignPlus, { /^\+$/ => :plus }
+    end
+
+    # token - The Token object we want to scan.
+    #
+    # Returns a new SignMinus object.
+    def self.scan_for_minus(token)
+      scan_for token, SignMinus, { /^-$/ => :minus }
+    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

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/tag.rb

@@ -6,8 +6,9 @@ module Chronic
     attr_accessor :type
 
     # type - The Symbol type of this tag.
-    def initialize(type)
+    def initialize(type, options = {})
       @type = type
+      @options = options
     end
 
     # time - Set the start Time for this Tag.
@@ -18,13 +19,13 @@ module Chronic
     class << self
       private
 
-      def scan_for(token, klass, items={})
+      def scan_for(token, klass, items={}, options = {})
         case items
         when Regexp
-          return klass.new(token.word) if items =~ token.word
+          return klass.new(token.word, options) if items =~ token.word
         when Hash
           items.each do |item, symbol|
-            return klass.new(symbol) if item =~ token.word
+            return klass.new(symbol, options) if item =~ token.word
           end
         end
         nil

data/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)
+      hour >= 0 && hour <= 24
+    end
+
+    # Checks if given number could be minute
+    def self.could_be_minute?(minute)
+      minute >= 0 && minute <= 60
+    end
+
+    # Checks if given number could be second
+    def self.could_be_second?(second)
+      second >= 0 && second <= 60
+    end
+
+    # Checks if given number could be subsecond
+    def self.could_be_subsecond?(subsecond)
+      subsecond >= 0 && subsecond <= 999999
+    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

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

@@ -2,6 +2,8 @@ require 'time'
 require 'date'
 
 require 'chronic/parser'
+require 'chronic/date'
+require 'chronic/time'
 
 require 'chronic/handler'
 require 'chronic/handlers'
@@ -13,8 +15,8 @@ require 'chronic/grabber'
 require 'chronic/pointer'
 require 'chronic/scalar'
 require 'chronic/ordinal'
-require 'chronic/ordinal'
 require 'chronic/separator'
+require 'chronic/sign'
 require 'chronic/time_zone'
 require 'chronic/numerizer'
 require 'chronic/season'
@@ -51,7 +53,7 @@ require 'chronic/repeaters/repeater_time'
 #   Chronic.parse('monday', :context => :past)
 #     #=> Mon Aug 21 12:00:00 PDT 2006
 module Chronic
-  VERSION = "0.9.0"
+  VERSION = "0.10.2"
 
   class << self
 
@@ -73,7 +75,7 @@ module Chronic
   end
 
   self.debug = false
-  self.time_class = Time
+  self.time_class = ::Time
 
 
   # Parses a string containing a natural language date or time.
@@ -99,7 +101,7 @@ module Chronic
   # 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)
+  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
@@ -118,11 +120,8 @@ module Chronic
     # 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 > 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
@@ -138,8 +137,14 @@ module Chronic
         month = month % 12
       end
     end
-
-    Chronic.time_class.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

data/test/helper.rb

@@ -5,8 +5,8 @@ end
 
 require 'minitest/autorun'
 
-class TestCase < MiniTest::Unit::TestCase
+class TestCase < MiniTest::Test
   def self.test(name, &block)
     define_method("test_#{name.gsub(/\W/, '_')}", &block) if block
   end
-end
+end

data/test/test_chronic.rb

@@ -58,10 +58,10 @@ class TestChronic < TestCase
   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_month, :separator_slash_or_dash, :scalar_day, :separator_at?, 'time?'], :handle_sm_sd),
-      Chronic::Handler.new([:scalar_day, :separator_slash_or_dash, :scalar_month, :separator_at?, 'time?'], :handle_sd_sm),
-      Chronic::Handler.new([:scalar_day, :separator_slash_or_dash, :scalar_month, :separator_slash_or_dash, :scalar_year, :separator_at?, 'time?'], :handle_sd_sm_sy)
+      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]
@@ -129,4 +129,55 @@ class TestChronic < TestCase
     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_handler.rb

@@ -105,4 +105,24 @@ class TestHandler < TestCase
     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

data/test/test_numerizer.rb

@@ -57,6 +57,20 @@ class ParseNumbersTest < TestCase
       'second day' => '2nd day',
       'second of may' => '2nd of may',
       'fifth' => '5th',
+      'twelfth' => '12th',
+      'twentieth' => '20th',
+      'thirtieth' => '30th',
+      'fourtieth' => '40th',
+      'fiftieth' => '50th',
+      'sixtieth' => '60th',
+      'seventieth' => '70th',
+      'eightieth' => '80th',
+      'ninetieth' => '90th',
+      'hundredth' => '100th',
+      'thousandth' => '1000th',
+      'millionth' => '1000000th',
+      'billionth' => '1000000000th',
+      'trillionth' => '1000000000000th',
       'twenty third' => '23rd',
       'first day month two' => '1st day month 2'
     }.each do |key, val|

data/test/test_parsing.rb

@@ -18,12 +18,25 @@ class TestParsing < TestCase
     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("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_equal time, time2
+    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
@@ -59,6 +72,9 @@ class TestParsing < TestCase
 
     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
@@ -164,8 +180,14 @@ class TestParsing < TestCase
     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
@@ -282,6 +304,9 @@ class TestParsing < TestCase
     # 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
@@ -293,6 +318,15 @@ class TestParsing < TestCase
 
     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("30-07-2013 21:53:49")
+    assert_equal Time.local(2013, 7, 30, 21, 53, 49), time
   end
 
   def test_handle_sy_sm_sd
@@ -317,9 +351,18 @@ class TestParsing < TestCase
     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
@@ -363,12 +406,41 @@ class TestParsing < TestCase
   #   assert_equal 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
@@ -1135,6 +1207,24 @@ class TestParsing < TestCase
     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
+
   private
   def parse_now(string, options={})
     Chronic.parse(string, {:now => TIME_2006_08_16_14_00_00 }.merge(options))