chronic 0.2.2 → 0.10.2

data/test/{test_Handler.rb → test_handler.rb}

@@ -1,110 +1,128 @@
-require 'chronic'
-require 'test/unit'
+require 'helper'
+
+class TestHandler < TestCase
 
-class TestHandler < 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 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
     handler = Chronic::Handler.new([:repeater, :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)
+
     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
     handler = Chronic::Handler.new([:repeater, 'time?'], :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_4
     handler = Chronic::Handler.new([:repeater_month_name, :scalar_day, 'time?'], :handler)
-    
+
     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
     handler = Chronic::Handler.new([:repeater, 'time?'], :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('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
     handler = Chronic::Handler.new([:scalar, :repeater, :pointer], :handler)
-    
+
     tokens = [Chronic::Token.new('3'),
               Chronic::Token.new('years'),
               Chronic::Token.new('past')]
-              
+
     tokens[0].tag(Chronic::Scalar.new(3))
     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_constantize
-    handler = Chronic::Handler.new([], :handler)
-    assert_equal Chronic::RepeaterTime, handler.constantize(:repeater_time)
+
+  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
+
+end

data/test/test_mini_date.rb

@@ -0,0 +1,32 @@
+require 'helper'
+
+class TestMiniDate < TestCase
+  def test_valid_month
+    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))
+
+    #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

@@ -0,0 +1,86 @@
+require 'helper'
+
+class ParseNumbersTest < 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',
+      '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::Parser.new.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