chronic 0.6.3 → 0.10.2

data/test/{test_Chronic.rb → test_chronic.rb}

@@ -1,15 +1,19 @@
 require 'helper'
 
-class TestChronic < Test::Unit::TestCase
+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.pre_normalize(string)
+    assert_equal Chronic::Numerizer.numerize(string), Chronic::Parser.new.pre_normalize(string)
   end
 
   def test_post_normalize_am_pm_aliases
@@ -42,50 +46,34 @@ class TestChronic < Test::Unit::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
     # 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)
+      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.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
 
@@ -131,11 +119,7 @@ class TestChronic < Test::Unit::TestCase
     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
+    assert_raises(RuntimeError) do
       Chronic.construct(2006, 1, 57)
     end
   end
@@ -145,4 +129,55 @@ class TestChronic < Test::Unit::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_DaylightSavings.rb → 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)

data/test/{test_Handler.rb → 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::Parser.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 @@ class TestHandler < Test::Unit::TestCase
     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 @@ class TestHandler < Test::Unit::TestCase
     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 @@ class TestHandler < Test::Unit::TestCase
     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 @@ class TestHandler < Test::Unit::TestCase
     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 @@ class TestHandler < Test::Unit::TestCase
     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

data/test/{test_MiniDate.rb → 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

data/test/{test_Numerizer.rb → test_numerizer.rb}

@@ -1,6 +1,6 @@
 require 'helper'
 
-class ParseNumbersTest < Test::Unit::TestCase
+class ParseNumbersTest < TestCase
 
   def test_straight_parsing
     strings = {
@@ -57,12 +57,26 @@ class ParseNumbersTest < Test::Unit::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|
       # Use pre_normalize here instead of Numerizer directly because
       # pre_normalize deals with parsing 'second' appropriately
-      assert_equal val, Chronic.pre_normalize(key)
+      assert_equal val, Chronic::Parser.new.pre_normalize(key)
     end
   end