chronic 0.1.6 → 0.2.3

data/lib/chronic/repeaters/repeater_time.rb

@@ -28,17 +28,20 @@ class Chronic::RepeaterTime < Chronic::Repeater #:nodoc:
     t = time.gsub(/\:/, '')
     @type = 
     if (1..2) === t.size
-      Tick.new(t.to_i * 60 * 60, true)
+      hours = t.to_i
+      hours == 12 ? Tick.new(0 * 60 * 60, true) : Tick.new(hours * 60 * 60, true)
     elsif t.size == 3
       Tick.new((t[0..0].to_i * 60 * 60) + (t[1..2].to_i * 60), true)
     elsif t.size == 4
       ambiguous = time =~ /:/ && t[0..0].to_i != 0 && t[0..1].to_i <= 12
-      Tick.new(t[0..1].to_i * 60 * 60 + t[2..3].to_i * 60, ambiguous)
+      hours = t[0..1].to_i
+      hours == 12 ? Tick.new(0 * 60 * 60 + t[2..3].to_i * 60, ambiguous) : Tick.new(hours * 60 * 60 + t[2..3].to_i * 60, ambiguous)
     elsif t.size == 5
       Tick.new(t[0..0].to_i * 60 * 60 + t[1..2].to_i * 60 + t[3..4].to_i, true)
     elsif t.size == 6
       ambiguous = time =~ /:/ && t[0..0].to_i != 0 && t[0..1].to_i <= 12
-      Tick.new(t[0..1].to_i * 60 * 60 + t[2..3].to_i * 60 + t[4..5].to_i, ambiguous)
+      hours = t[0..1].to_i
+      hours == 12 ? Tick.new(0 * 60 * 60 + t[2..3].to_i * 60 + t[4..5].to_i, ambiguous) : Tick.new(hours * 60 * 60 + t[2..3].to_i * 60 + t[4..5].to_i, ambiguous)
     else
       raise("Time cannot exceed six digits")
     end
@@ -65,21 +68,21 @@ class Chronic::RepeaterTime < Chronic::Repeater #:nodoc:
         if pointer == :future
           if @type.ambiguous?
             [midnight + @type, midnight + half_day + @type, tomorrow_midnight + @type].each do |t|
-              (@current_time = t; throw :done) if t > @now
+              (@current_time = t; throw :done) if t >= @now
             end
           else
             [midnight + @type, tomorrow_midnight + @type].each do |t|
-              (@current_time = t; throw :done) if t > @now
+              (@current_time = t; throw :done) if t >= @now
             end
           end
         else # pointer == :past
           if @type.ambiguous?
             [midnight + half_day + @type, midnight + @type, yesterday_midnight + @type * 2].each do |t|
-              (@current_time = t; throw :done) if t < @now
+              (@current_time = t; throw :done) if t <= @now
             end
           else
             [midnight + @type, yesterday_midnight + @type].each do |t|
-              (@current_time = t; throw :done) if t < @now
+              (@current_time = t; throw :done) if t <= @now
             end
           end
         end

data/lib/chronic/repeaters/repeater_year.rb

@@ -6,16 +6,16 @@ class Chronic::RepeaterYear < Chronic::Repeater #:nodoc:
     if !@current_year_start
       case pointer
       when :future
-        @current_year_start = Time.local(@now.year + 1)
+        @current_year_start = Time.construct(@now.year + 1)
       when :past
-        @current_year_start = Time.local(@now.year - 1)
+        @current_year_start = Time.construct(@now.year - 1)
       end
     else
       diff = pointer == :future ? 1 : -1
-      @current_year_start = Time.local(@current_year_start.year + diff)
+      @current_year_start = Time.construct(@current_year_start.year + diff)
     end
     
-    Chronic::Span.new(@current_year_start, Time.local(@current_year_start.year + 1))
+    Chronic::Span.new(@current_year_start, Time.construct(@current_year_start.year + 1))
   end
   
   def this(pointer = :future)
@@ -23,14 +23,14 @@ class Chronic::RepeaterYear < Chronic::Repeater #:nodoc:
     
     case pointer
     when :future
-      this_year_start = Time.local(@now.year, @now.month, @now.day) + Chronic::RepeaterDay::DAY_SECONDS
-      this_year_end = Time.local(@now.year + 1, 1, 1)
+      this_year_start = Time.construct(@now.year, @now.month, @now.day) + Chronic::RepeaterDay::DAY_SECONDS
+      this_year_end = Time.construct(@now.year + 1, 1, 1)
     when :past
-      this_year_start = Time.local(@now.year, 1, 1)
-      this_year_end = Time.local(@now.year, @now.month, @now.day)
+      this_year_start = Time.construct(@now.year, 1, 1)
+      this_year_end = Time.construct(@now.year, @now.month, @now.day)
     when :none
-      this_year_start = Time.local(@now.year, 1, 1)
-      this_year_end = Time.local(@now.year + 1, 1, 1)
+      this_year_start = Time.construct(@now.year, 1, 1)
+      this_year_end = Time.construct(@now.year + 1, 1, 1)
     end
     
     Chronic::Span.new(this_year_start, this_year_end)
@@ -40,10 +40,10 @@ class Chronic::RepeaterYear < Chronic::Repeater #:nodoc:
     direction = pointer == :future ? 1 : -1
     
     sb = span.begin
-    new_begin = Time.local(sb.year + (amount * direction), sb.month, sb.day, sb.hour, sb.min, sb.sec)
+    new_begin = Time.construct(sb.year + (amount * direction), sb.month, sb.day, sb.hour, sb.min, sb.sec)
     
     se = span.end
-    new_end = Time.local(se.year + (amount * direction), se.month, se.day, se.hour, se.min, se.sec)
+    new_end = Time.construct(se.year + (amount * direction), se.month, se.day, se.hour, se.min, se.sec)
     
     Chronic::Span.new(new_begin, new_end)
   end

data/lib/chronic/time_zone.rb

@@ -0,0 +1,22 @@
+module Chronic
+  class TimeZone < Tag #:nodoc:    
+    def self.scan(tokens)
+      tokens.each_index do |i|
+        if t = self.scan_for_all(tokens[i]) then tokens[i].tag(t); next end
+      end
+      tokens
+    end
+
+    def self.scan_for_all(token)
+      scanner = {/[PMCE][DS]T/i => :tz}
+      scanner.keys.each do |scanner_item|
+        return self.new(scanner[scanner_item]) if scanner_item =~ token.word
+      end
+      return nil
+    end
+
+    def to_s
+      'timezone'
+    end
+  end
+end

data/lib/chronic.rb

@@ -7,6 +7,8 @@
 #
 #=============================================================================
 
+$:.unshift File.dirname(__FILE__)     # For use/testing when no gem is installed
+
 require 'chronic/chronic'
 require 'chronic/handlers'
 
@@ -32,9 +34,12 @@ require 'chronic/pointer'
 require 'chronic/scalar'
 require 'chronic/ordinal'
 require 'chronic/separator'
+require 'chronic/time_zone'
+
+require 'numerizer/numerizer'
 
 module Chronic
-  VERSION = "0.1.6"
+  VERSION = "0.2.3"
   
   def self.debug; false; end
 end
@@ -44,4 +49,77 @@ alias p_orig p
 def p(val)
   p_orig val
   puts
+end
+
+# class Time
+#   def self.construct(year, month = 1, day = 1, hour = 0, minute = 0, second = 0)
+#     # extra_seconds = second > 60 ? second - 60 : 0
+#     # extra_minutes = minute > 59 ? minute - 59 : 0
+#     # extra_hours = hour > 23 ? hour - 23 : 0
+#     # extra_days = day > 
+#     
+#     if month > 12
+#       if month % 12 == 0
+#         year += (month - 12) / 12
+#         month = 12
+#       else
+#         year += month / 12
+#         month = month % 12
+#       end
+#     end
+#     
+#     base = Time.local(year, month)
+#     puts base
+#     offset = ((day - 1) * 24 * 60 * 60) + (hour * 60 * 60) + (minute * 60) + second
+#     puts offset.to_s
+#     date = base + offset
+#     puts date
+#     date
+#   end
+# end
+
+class Time
+  def self.construct(year, month = 1, day = 1, hour = 0, minute = 0, second = 0)
+    if second >= 60
+      minute += second / 60
+      second = second % 60
+    end
+    
+    if minute >= 60
+      hour += minute / 60
+      minute = minute % 60
+    end
+    
+    if hour >= 24
+      day += hour / 24
+      hour = hour % 24
+    end
+    
+    # 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 = (year % 4 == 0) && !(year % 100 == 0)
+      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 = leap_year ? leap_year_month_days[month - 1] : common_year_month_days[month - 1]
+      if day > days_this_month
+        month += day / days_this_month
+        day = day % days_this_month
+      end
+    end
+    
+    if month > 12
+      if month % 12 == 0
+        year += (month - 12) / 12
+        month = 12
+      else
+        year += month / 12
+        month = month % 12
+      end
+    end
+    
+    Time.local(year, month, day, hour, minute, second)
+  end
 end

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_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