chronic 0.1.0 → 0.2.2

data/lib/numerizer/numerizer.rb

@@ -0,0 +1,103 @@
+require 'strscan'
+
+class Numerizer
+
+  DIRECT_NUMS = [
+                  ['eleven', '11'],
+                  ['twelve', '12'],
+                  ['thirteen', '13'],
+                  ['fourteen', '14'],
+                  ['fifteen', '15'],
+                  ['sixteen', '16'],
+                  ['seventeen', '17'],
+                  ['eighteen', '18'],
+                  ['nineteen', '19'],
+                  ['ninteen', '19'], # Common mis-spelling
+                  ['zero', '0'],
+                  ['one', '1'],
+                  ['two', '2'],
+                  ['three', '3'],
+                  ['four(\W|$)', '4\1'],  # The weird regex is so that it matches four but not fourty
+                  ['five', '5'],
+                  ['six(\W|$)', '6\1'],
+                  ['seven(\W|$)', '7\1'],
+                  ['eight(\W|$)', '8\1'],
+                  ['nine(\W|$)', '9\1'],
+                  ['ten', '10'],
+                  ['\ba[\b^$]', '1'] # doesn't make sense for an 'a' at the end to be a 1
+                ]
+
+  TEN_PREFIXES = [ ['twenty', 20],
+                    ['thirty', 30],
+                    ['fourty', 40],
+                    ['fifty', 50],
+                    ['sixty', 60],
+                    ['seventy', 70],
+                    ['eighty', 80],
+                    ['ninety', 90]
+                  ]
+
+  BIG_PREFIXES = [ ['hundred', 100],
+                    ['thousand', 1000],
+                    ['million', 1_000_000],
+                    ['billion', 1_000_000_000],
+                    ['trillion', 1_000_000_000_000],
+                  ]
+
+class << self
+  def numerize(string)
+    string = string.dup
+  
+    # preprocess
+    string.gsub!(/ +|([^\d])-([^d])/, '\1 \2') # will mutilate hyphenated-words but shouldn't matter for date extraction
+    string.gsub!(/a half/, 'haAlf') # take the 'a' out so it doesn't turn into a 1, save the half for the end
+
+    # easy/direct replacements
+  
+    DIRECT_NUMS.each do |dn|
+      string.gsub!(/#{dn[0]}/i, dn[1])
+    end
+
+    # ten, twenty, etc.
+
+    TEN_PREFIXES.each do |tp|
+      string.gsub!(/(?:#{tp[0]})( *\d(?=[^\d]|$))*/i) { (tp[1] + $1.to_i).to_s }
+    end
+
+    # hundreds, thousands, millions, etc.
+
+    BIG_PREFIXES.each do |bp|
+      string.gsub!(/(\d*) *#{bp[0]}/i) { (bp[1] * $1.to_i).to_s}
+      andition(string)
+      #combine_numbers(string) # Should to be more efficient way to do this
+    end
+
+    # fractional addition
+    # I'm not combining this with the previous block as using float addition complicates the strings
+    # (with extraneous .0's and such )
+    string.gsub!(/(\d+)(?: | and |-)*haAlf/i) { ($1.to_f + 0.5).to_s }
+
+    string
+  end
+
+private
+  def andition(string)
+    sc = StringScanner.new(string)
+    while(sc.scan_until(/(\d+)( | and )(\d+)(?=[^\w]|$)/i))
+      if sc[2] =~ /and/ || sc[1].size > sc[3].size
+        string[(sc.pos - sc.matched_size)..(sc.pos-1)] = (sc[1].to_i + sc[3].to_i).to_s
+        sc.reset
+      end
+    end
+  end
+
+#  def combine_numbers(string)
+#    sc = StringScanner.new(string)
+#    while(sc.scan_until(/(\d+)(?: | and |-)(\d+)(?=[^\w]|$)/i))
+#      string[(sc.pos - sc.matched_size)..(sc.pos-1)] = (sc[1].to_i + sc[2].to_i).to_s
+#      sc.reset
+#    end
+#  end
+
+end
+end

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

@@ -1,11 +1,10 @@
-__END__
-
 require 'test/unit'
+require 'chronic'
 
 class ParseNumbersTest < Test::Unit::TestCase
 
-  def test_parse
-    strings = {1 => 'one',
+  def test_straight_parsing
+    strings = { 1 => 'one',
                5 => 'five',
                10 => 'ten',
                11 => 'eleven',
@@ -24,7 +23,7 @@ class ParseNumbersTest < Test::Unit::TestCase
                100 => 'a hundred',
                100 => 'one hundred',
                150 => 'one hundred and fifty',
-               150 => 'one fifty',
+            #   150 => 'one fifty',
                200 => 'two-hundred',
                500 => '5 hundred',
                999 => 'nine hundred and ninety nine',
@@ -40,11 +39,10 @@ class ParseNumbersTest < Test::Unit::TestCase
                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'}
+               1_000_000_001 => 'one billion and one' }
                
     strings.keys.sort.each do |key|
-      assert_equal key, JW::NumberMagick.convert(strings[key])
+      assert_equal key, Numerizer.numerize(strings[key]).to_i
     end
   end
-  
 end

data/test/test_RepeaterWeekend.rb

@@ -0,0 +1,75 @@
+require 'chronic'
+require 'test/unit'
+
+class TestRepeaterWeekend < Test::Unit::TestCase
+  
+  def setup
+    # Wed Aug 16 14:00:00 2006
+    @now = Time.local(2006, 8, 16, 14, 0, 0, 0)
+  end
+  
+  def test_next_future
+    weekend = Chronic::RepeaterWeekend.new(:weekend)
+    weekend.start = @now
+    
+    next_weekend = weekend.next(:future)
+    assert_equal Time.local(2006, 8, 19), next_weekend.begin
+    assert_equal Time.local(2006, 8, 21), next_weekend.end
+  end
+  
+  def test_next_past
+    weekend = Chronic::RepeaterWeekend.new(:weekend)
+    weekend.start = @now
+    
+    next_weekend = weekend.next(:past)
+    assert_equal Time.local(2006, 8, 12), next_weekend.begin
+    assert_equal Time.local(2006, 8, 14), next_weekend.end
+  end
+  
+  def test_this_future
+    weekend = Chronic::RepeaterWeekend.new(:weekend)
+    weekend.start = @now
+    
+    next_weekend = weekend.this(:future)
+    assert_equal Time.local(2006, 8, 19), next_weekend.begin
+    assert_equal Time.local(2006, 8, 21), next_weekend.end
+  end
+  
+  def test_this_past
+    weekend = Chronic::RepeaterWeekend.new(:weekend)
+    weekend.start = @now
+    
+    next_weekend = weekend.this(:past)
+    assert_equal Time.local(2006, 8, 12), next_weekend.begin
+    assert_equal Time.local(2006, 8, 14), next_weekend.end
+  end
+  
+  def test_this_none
+    weekend = Chronic::RepeaterWeekend.new(:weekend)
+    weekend.start = @now
+    
+    next_weekend = weekend.this(:future)
+    assert_equal Time.local(2006, 8, 19), next_weekend.begin
+    assert_equal Time.local(2006, 8, 21), next_weekend.end
+  end
+  
+  def test_offset
+    span = Chronic::Span.new(@now, @now + 1)
+    
+    offset_span = Chronic::RepeaterWeekend.new(:weekend).offset(span, 3, :future)
+    
+    assert_equal Time.local(2006, 9, 2), offset_span.begin
+    assert_equal Time.local(2006, 9, 2, 0, 0, 1), offset_span.end
+    
+    offset_span = Chronic::RepeaterWeekend.new(:weekend).offset(span, 1, :past)
+    
+    assert_equal Time.local(2006, 8, 12), offset_span.begin
+    assert_equal Time.local(2006, 8, 12, 0, 0, 1), offset_span.end
+    
+    offset_span = Chronic::RepeaterWeekend.new(:weekend).offset(span, 0, :future)
+    
+    assert_equal Time.local(2006, 8, 12), offset_span.begin
+    assert_equal Time.local(2006, 8, 12, 0, 0, 1), offset_span.end
+  end
+  
+end

data/test/test_Time.rb

@@ -0,0 +1,50 @@
+require 'chronic'
+require 'test/unit'
+
+class TestTime < Test::Unit::TestCase
+  
+  def setup
+  end
+  
+  def test_normal
+    assert_equal Time.local(2006, 1, 2, 0, 0, 0), Time.construct(2006, 1, 2, 0, 0, 0)
+    assert_equal Time.local(2006, 1, 2, 3, 0, 0), Time.construct(2006, 1, 2, 3, 0, 0)
+    assert_equal Time.local(2006, 1, 2, 3, 4, 0), Time.construct(2006, 1, 2, 3, 4, 0)
+    assert_equal Time.local(2006, 1, 2, 3, 4, 5), Time.construct(2006, 1, 2, 3, 4, 5)
+  end
+  
+  def test_second_overflow
+    assert_equal Time.local(2006, 1, 1, 0, 1, 30), Time.construct(2006, 1, 1, 0, 0, 90)
+    assert_equal Time.local(2006, 1, 1, 0, 5, 0), Time.construct(2006, 1, 1, 0, 0, 300)
+  end
+  
+  def test_minute_overflow
+    assert_equal Time.local(2006, 1, 1, 1, 30), Time.construct(2006, 1, 1, 0, 90)
+    assert_equal Time.local(2006, 1, 1, 5), Time.construct(2006, 1, 1, 0, 300)
+  end
+  
+  def test_hour_overflow
+    assert_equal Time.local(2006, 1, 2, 12), Time.construct(2006, 1, 1, 36)
+    assert_equal Time.local(2006, 1, 7), Time.construct(2006, 1, 1, 144)
+  end
+  
+  def test_day_overflow
+    assert_equal Time.local(2006, 2, 1), Time.construct(2006, 1, 32)
+    assert_equal Time.local(2006, 3, 5), Time.construct(2006, 2, 33)
+    assert_equal Time.local(2004, 3, 4), Time.construct(2004, 2, 33)
+    assert_equal Time.local(2000, 3, 5), Time.construct(2000, 2, 33)
+    
+    assert_nothing_raised do
+      Time.construct(2006, 1, 56)
+    end
+    
+    assert_raise(RuntimeError) do
+      Time.construct(2006, 1, 57)
+    end
+  end
+  
+  def test_month_overflow
+    assert_equal Time.local(2006, 1), Time.construct(2005, 13)
+    assert_equal Time.local(2005, 12), Time.construct(2000, 72)
+  end
+end