pangel-chronic 0.3.0.3 → 0.3.10

data/test/test_Handler.rb

@@ -2,109 +2,109 @@ require 'chronic'
 require 'test/unit'
 
 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 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)
-
-		tokens << Chronic::Token.new('afternoon')
-		tokens[1].tag(Chronic::RepeaterDayPortion.new(:afternoon))
-
-		assert !handler.match(tokens, Chronic.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)
-
-		tokens << Chronic::Token.new('afternoon')
-		tokens[1].tag(Chronic::RepeaterDayPortion.new(:afternoon))
-
-		assert handler.match(tokens, Chronic.definitions)
-
-		tokens << Chronic::Token.new('afternoon')
-		tokens[2].tag(Chronic::RepeaterDayPortion.new(:afternoon))
-
-		assert !handler.match(tokens, Chronic.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)
-
-		tokens << Chronic::Token.new('afternoon')
-		tokens[1].tag(Chronic::RepeaterDayPortion.new(:afternoon))
-
-		assert !handler.match(tokens, Chronic.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)
-
-		tokens << Chronic::Token.new('27')
-		tokens[1].tag(Chronic::ScalarDay.new(27))
-
-		assert handler.match(tokens, Chronic.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)
-
-		tokens << Chronic::Token.new('5:00')
-		tokens[1].tag(Chronic::RepeaterTime.new('5:00'))
-
-		assert handler.match(tokens, Chronic.definitions)
-
-		tokens << Chronic::Token.new('pm')
-		tokens[2].tag(Chronic::RepeaterDayPortion.new(:pm))
-
-		assert handler.match(tokens, Chronic.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)
-	end
-
-	def test_constantize
-		handler = Chronic::Handler.new([], :handler)
-		assert_equal Chronic::RepeaterTime, handler.constantize(:repeater_time)
-	end
-
-end
+  
+  def setup
+    # Wed Aug 16 14:00:00 UTC 2006
+    @now = Time.local(2006, 8, 16, 14, 0, 0, 0)
+  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)
+    
+    tokens << Chronic::Token.new('afternoon')
+    tokens[1].tag(Chronic::RepeaterDayPortion.new(:afternoon))
+    
+    assert !handler.match(tokens, Chronic.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)
+    
+    tokens << Chronic::Token.new('afternoon')
+    tokens[1].tag(Chronic::RepeaterDayPortion.new(:afternoon))
+    
+    assert handler.match(tokens, Chronic.definitions)
+    
+    tokens << Chronic::Token.new('afternoon')
+    tokens[2].tag(Chronic::RepeaterDayPortion.new(:afternoon))
+    
+    assert !handler.match(tokens, Chronic.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)
+    
+    tokens << Chronic::Token.new('afternoon')
+    tokens[1].tag(Chronic::RepeaterDayPortion.new(:afternoon))
+    
+    assert !handler.match(tokens, Chronic.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)
+    
+    tokens << Chronic::Token.new('27')
+    tokens[1].tag(Chronic::ScalarDay.new(27))
+    
+    assert handler.match(tokens, Chronic.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)
+    
+    tokens << Chronic::Token.new('5:00')
+    tokens[1].tag(Chronic::RepeaterTime.new('5:00'))
+    
+    assert handler.match(tokens, Chronic.definitions)
+    
+    tokens << Chronic::Token.new('pm')
+    tokens[2].tag(Chronic::RepeaterDayPortion.new(:pm))
+    
+    assert handler.match(tokens, Chronic.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)
+  end
+  
+  def test_constantize
+    handler = Chronic::Handler.new([], :handler)
+    assert_equal Chronic::RepeaterTime, handler.constantize(:repeater_time)
+  end
+  
+end

data/test/test_Numerizer.rb

@@ -3,52 +3,50 @@ require 'chronic'
 
 class ParseNumbersTest < Test::Unit::TestCase
 
-	def test_straight_parsing
-		strings = { 1 => 'one',
-			5 => 'five',
-			10 => 'ten',
-			11 => 'eleven',
-			12 => 'twelve',
-			13 => 'thirteen',
-			14 => 'fourteen',
-			15 => 'fifteen',
-			16 => 'sixteen',
-			17 => 'seventeen',
-			18 => 'eighteen',
-			19 => 'nineteen',
-			20 => 'twenty',
-			27 => 'twenty seven',
-			31 => 'thirty-one',
-			41 => 'forty one',
-			42 => 'fourty two',
-			59 => 'fifty nine',
-			100 => 'a hundred',
-			100 => 'one hundred',
-			150 => 'one hundred and fifty',
-			# 150 => 'one fifty',
-			200 => 'two-hundred',
-			500 => '5 hundred',
-			999 => 'nine hundred and ninety nine',
-			1_000 => 'one thousand',
-			1_200 => 'twelve hundred',
-			1_200 => 'one thousand two hundred',
-			17_000 => 'seventeen thousand',
-			21_473 => 'twentyone-thousand-four-hundred-and-seventy-three',
-			74_002 => 'seventy four thousand and two',
-			99_999 => 'ninety nine thousand nine hundred ninety nine',
-			100_000 => '100 thousand',
-			250_000 => 'two hundred fifty thousand',
-			1_000_000 => 'one million',
-			1_250_007 => 'one million two hundred fifty thousand and seven',
-			1_000_000_000 => 'one billion',
-			1_000_000_001 => 'one billion and one' }
-
-		strings.keys.sort.each do |key|
-			assert_equal key, Numerizer.numerize(strings[key]).to_i
-		end
-	end
-
-	def test_edges
-		assert_equal "27 Oct 2006 7:30am", Numerizer.numerize("27 Oct 2006 7:30am")
-	end
-end
+  def test_straight_parsing
+    strings = { 1 => 'one',
+               5 => 'five',
+               10 => 'ten',
+               11 => 'eleven',
+               12 => 'twelve',
+               13 => 'thirteen',
+               14 => 'fourteen',
+               15 => 'fifteen',
+               16 => 'sixteen',
+               17 => 'seventeen',
+               18 => 'eighteen',
+               19 => 'nineteen',
+               20 => 'twenty',
+               27 => 'twenty seven',
+               31 => 'thirty-one',
+               59 => 'fifty nine',
+               100 => 'a hundred',
+               100 => 'one hundred',
+               150 => 'one hundred and fifty',
+               # 150 => 'one fifty',
+               200 => 'two-hundred',
+               500 => '5 hundred',
+               999 => 'nine hundred and ninety nine',
+               1_000 => 'one thousand',
+               1_200 => 'twelve hundred',
+               1_200 => 'one thousand two hundred',
+               17_000 => 'seventeen thousand',
+               21_473 => 'twentyone-thousand-four-hundred-and-seventy-three',
+               74_002 => 'seventy four thousand and two',
+               99_999 => 'ninety nine thousand nine hundred ninety nine',
+               100_000 => '100 thousand',
+               250_000 => 'two hundred fifty thousand',
+               1_000_000 => 'one million',
+               1_250_007 => 'one million two hundred fifty thousand and seven',
+               1_000_000_000 => 'one billion',
+               1_000_000_001 => 'one billion and one' }
+               
+    strings.keys.sort.each do |key|
+      assert_equal key, Numerizer.numerize(strings[key]).to_i
+    end
+  end
+  
+  def test_edges
+    assert_equal "27 Oct 2006 7:30am", Numerizer.numerize("27 Oct 2006 7:30am")
+  end
+end

data/test/test_RepeaterDayName.rb

@@ -2,51 +2,51 @@ require 'chronic'
 require 'test/unit'
 
 class TestRepeaterDayName < Test::Unit::TestCase
-
-	def setup
-		@now = Time.local(2006, 8, 16, 14, 0, 0, 0)
-	end
-
-	def test_match
-		token = Chronic::Token.new('saturday')
-		repeater = Chronic::Repeater.scan_for_day_names(token)
-		assert_equal Chronic::RepeaterDayName, repeater.class
-		assert_equal :saturday, repeater.type
-
-		token = Chronic::Token.new('sunday')
-		repeater = Chronic::Repeater.scan_for_day_names(token)
-		assert_equal Chronic::RepeaterDayName, repeater.class
-		assert_equal :sunday, repeater.type
-	end
-
-	def test_next_future
-		mondays = Chronic::RepeaterDayName.new(:monday)
-		mondays.start = @now
-
-		span = mondays.next(:future)
-
-		assert_equal Time.local(2006, 8, 21), span.begin
-		assert_equal Time.local(2006, 8, 22), span.end
-
-		span = mondays.next(:future)
-
-		assert_equal Time.local(2006, 8, 28), span.begin
-		assert_equal Time.local(2006, 8, 29), span.end
-	end
-
-	def test_next_past
-		mondays = Chronic::RepeaterDayName.new(:monday)
-		mondays.start = @now
-
-		span = mondays.next(:past)
-
-		assert_equal Time.local(2006, 8, 14), span.begin
-		assert_equal Time.local(2006, 8, 15), span.end
-
-		span = mondays.next(:past)
-
-		assert_equal Time.local(2006, 8, 7), span.begin
-		assert_equal Time.local(2006, 8, 8), span.end
-	end
-
-end
+  
+  def setup
+    @now = Time.local(2006, 8, 16, 14, 0, 0, 0)
+  end
+  
+  def test_match
+    token = Chronic::Token.new('saturday')
+    repeater = Chronic::Repeater.scan_for_day_names(token)
+    assert_equal Chronic::RepeaterDayName, repeater.class
+    assert_equal :saturday, repeater.type
+    
+    token = Chronic::Token.new('sunday')
+    repeater = Chronic::Repeater.scan_for_day_names(token)
+    assert_equal Chronic::RepeaterDayName, repeater.class
+    assert_equal :sunday, repeater.type
+  end
+
+  def test_next_future
+    mondays = Chronic::RepeaterDayName.new(:monday)
+    mondays.start = @now
+    
+    span = mondays.next(:future)
+    
+    assert_equal Time.local(2006, 8, 21), span.begin
+    assert_equal Time.local(2006, 8, 22), span.end 
+
+    span = mondays.next(:future)
+    
+    assert_equal Time.local(2006, 8, 28), span.begin
+    assert_equal Time.local(2006, 8, 29), span.end
+  end
+  
+  def test_next_past
+    mondays = Chronic::RepeaterDayName.new(:monday)
+    mondays.start = @now
+    
+    span = mondays.next(:past)
+    
+    assert_equal Time.local(2006, 8, 14), span.begin
+    assert_equal Time.local(2006, 8, 15), span.end 
+
+    span = mondays.next(:past)
+    
+    assert_equal Time.local(2006, 8, 7), span.begin
+    assert_equal Time.local(2006, 8, 8), span.end
+  end
+  
+end

data/test/test_RepeaterFortnight.rb

@@ -2,62 +2,62 @@ require 'chronic'
 require 'test/unit'
 
 class TestRepeaterFortnight < Test::Unit::TestCase
-
-	def setup
-		@now = Time.local(2006, 8, 16, 14, 0, 0, 0)
-	end
-
-	def test_next_future
-		fortnights = Chronic::RepeaterFortnight.new(:fortnight)
-		fortnights.start = @now
-
-		next_fortnight = fortnights.next(:future)
-		assert_equal Time.local(2006, 8, 20), next_fortnight.begin
-		assert_equal Time.local(2006, 9, 3), next_fortnight.end
-
-		next_next_fortnight = fortnights.next(:future)
-		assert_equal Time.local(2006, 9, 3), next_next_fortnight.begin
-		assert_equal Time.local(2006, 9, 17), next_next_fortnight.end
-	end
-
-	def test_next_past
-		fortnights = Chronic::RepeaterFortnight.new(:fortnight)
-		fortnights.start = @now
-
-		last_fortnight = fortnights.next(:past)
-		assert_equal Time.local(2006, 7, 30), last_fortnight.begin
-		assert_equal Time.local(2006, 8, 13), last_fortnight.end
-
-		last_last_fortnight = fortnights.next(:past)
-		assert_equal Time.local(2006, 7, 16), last_last_fortnight.begin
-		assert_equal Time.local(2006, 7, 30), last_last_fortnight.end
-	end
-
-	def test_this_future
-		fortnights = Chronic::RepeaterFortnight.new(:fortnight)
-		fortnights.start = @now
-
-		this_fortnight = fortnights.this(:future)
-		assert_equal Time.local(2006, 8, 16, 15), this_fortnight.begin
-		assert_equal Time.local(2006, 8, 27), this_fortnight.end
-	end
-
-	def test_this_past
-		fortnights = Chronic::RepeaterFortnight.new(:fortnight)
-		fortnights.start = @now
-
-		this_fortnight = fortnights.this(:past)
-		assert_equal Time.local(2006, 8, 13, 0), this_fortnight.begin
-		assert_equal Time.local(2006, 8, 16, 14), this_fortnight.end
-	end
-
-	def test_offset
-		span = Chronic::Span.new(@now, @now + 1)
-
-		offset_span = Chronic::RepeaterFortnight.new(:week).offset(span, 3, :future)
-
-		assert_equal Time.local(2006, 9, 27, 14), offset_span.begin
-		assert_equal Time.local(2006, 9, 27, 14, 0, 1), offset_span.end
-	end
-
-end
+  
+  def setup
+    @now = Time.local(2006, 8, 16, 14, 0, 0, 0)
+  end
+
+  def test_next_future
+    fortnights = Chronic::RepeaterFortnight.new(:fortnight)
+    fortnights.start = @now
+    
+    next_fortnight = fortnights.next(:future)
+    assert_equal Time.local(2006, 8, 20), next_fortnight.begin
+    assert_equal Time.local(2006, 9, 3), next_fortnight.end
+    
+    next_next_fortnight = fortnights.next(:future)
+    assert_equal Time.local(2006, 9, 3), next_next_fortnight.begin
+    assert_equal Time.local(2006, 9, 17), next_next_fortnight.end
+  end
+  
+  def test_next_past
+    fortnights = Chronic::RepeaterFortnight.new(:fortnight)
+    fortnights.start = @now
+    
+    last_fortnight = fortnights.next(:past)
+    assert_equal Time.local(2006, 7, 30), last_fortnight.begin
+    assert_equal Time.local(2006, 8, 13), last_fortnight.end
+    
+    last_last_fortnight = fortnights.next(:past)
+    assert_equal Time.local(2006, 7, 16), last_last_fortnight.begin
+    assert_equal Time.local(2006, 7, 30), last_last_fortnight.end
+  end
+  
+  def test_this_future
+    fortnights = Chronic::RepeaterFortnight.new(:fortnight)
+    fortnights.start = @now
+    
+    this_fortnight = fortnights.this(:future)
+    assert_equal Time.local(2006, 8, 16, 15), this_fortnight.begin
+    assert_equal Time.local(2006, 8, 27), this_fortnight.end
+  end
+  
+  def test_this_past
+    fortnights = Chronic::RepeaterFortnight.new(:fortnight)
+    fortnights.start = @now
+    
+    this_fortnight = fortnights.this(:past)
+    assert_equal Time.local(2006, 8, 13, 0), this_fortnight.begin
+    assert_equal Time.local(2006, 8, 16, 14), this_fortnight.end
+  end
+  
+  def test_offset
+    span = Chronic::Span.new(@now, @now + 1)
+    
+    offset_span = Chronic::RepeaterWeek.new(:week).offset(span, 3, :future)
+    
+    assert_equal Time.local(2006, 9, 6, 14), offset_span.begin
+    assert_equal Time.local(2006, 9, 6, 14, 0, 1), offset_span.end
+  end
+  
+end