chronic 0.2.0 → 0.3.0

data/lib/chronic/repeaters/repeater_week.rb

@@ -1,9 +1,14 @@
 class Chronic::RepeaterWeek < Chronic::Repeater #:nodoc:
   WEEK_SECONDS = 604800 # (7 * 24 * 60 * 60)
-  
+
+  def initialize(type)
+    super
+    @current_week_start = nil
+  end
+
   def next(pointer)
     super
-    
+
     if !@current_week_start
       case pointer
       when :future
@@ -22,23 +27,23 @@ class Chronic::RepeaterWeek < Chronic::Repeater #:nodoc:
       direction = pointer == :future ? 1 : -1
       @current_week_start += direction * WEEK_SECONDS
     end
-    
+
     Chronic::Span.new(@current_week_start, @current_week_start + WEEK_SECONDS)
   end
-  
+
   def this(pointer = :future)
     super
-    
+
     case pointer
     when :future
-      this_week_start = Time.local(@now.year, @now.month, @now.day, @now.hour) + Chronic::RepeaterHour::HOUR_SECONDS
+      this_week_start = Chronic.time_class.local(@now.year, @now.month, @now.day, @now.hour) + Chronic::RepeaterHour::HOUR_SECONDS
       sunday_repeater = Chronic::RepeaterDayName.new(:sunday)
       sunday_repeater.start = @now
       this_sunday_span = sunday_repeater.this(:future)
       this_week_end = this_sunday_span.begin
       Chronic::Span.new(this_week_start, this_week_end)
     when :past
-      this_week_end = Time.local(@now.year, @now.month, @now.day, @now.hour)
+      this_week_end = Chronic.time_class.local(@now.year, @now.month, @now.day, @now.hour)
       sunday_repeater = Chronic::RepeaterDayName.new(:sunday)
       sunday_repeater.start = @now
       last_sunday_span = sunday_repeater.next(:past)
@@ -52,17 +57,17 @@ class Chronic::RepeaterWeek < Chronic::Repeater #:nodoc:
       Chronic::Span.new(this_week_start, this_week_start + WEEK_SECONDS)
     end
   end
-  
+
   def offset(span, amount, pointer)
     direction = pointer == :future ? 1 : -1
     span + direction * amount * WEEK_SECONDS
   end
-  
+
   def width
     WEEK_SECONDS
   end
-  
+
   def to_s
     super << '-week'
   end
-end
+end

data/lib/chronic/repeaters/repeater_weekday.rb

@@ -0,0 +1,77 @@
+class Chronic::RepeaterWeekday < Chronic::Repeater #:nodoc:
+  WEEK_WEEKDAYS = 5
+  DAY_SECONDS = 86400 # (24 * 60 * 60)
+
+  def initialize(type)
+    super
+    @current_weekday_start = nil
+  end
+
+  def next(pointer)
+    super
+
+    direction = pointer == :future ? 1 : -1
+
+    if !@current_weekday_start
+      @current_weekday_start = Time.construct(@now.year, @now.month, @now.day)
+      @current_weekday_start += direction * DAY_SECONDS
+
+      until is_weekday?(@current_weekday_start.wday)
+        @current_weekday_start += direction * DAY_SECONDS
+      end
+    else
+      loop do
+        @current_weekday_start += direction * DAY_SECONDS
+        break if is_weekday?(@current_weekday_start.wday)
+      end
+    end
+
+    Chronic::Span.new(@current_weekday_start, @current_weekday_start + DAY_SECONDS)
+  end
+
+  def this(pointer = :future)
+    super
+
+    case pointer
+    when :past
+      self.next(:past)
+    when :future, :none
+      self.next(:future)
+    end
+  end
+
+  def offset(span, amount, pointer)
+    direction = pointer == :future ? 1 : -1
+
+    num_weekdays_passed = 0; offset = 0
+    until num_weekdays_passed == amount
+      offset += direction * DAY_SECONDS
+      num_weekdays_passed += 1 if is_weekday?((span.begin+offset).wday)
+    end
+
+    span + offset
+  end
+
+  def width
+    DAY_SECONDS
+  end
+
+  def to_s
+    super << '-weekday'
+  end
+
+  private
+
+  def is_weekend?(day)
+    day == symbol_to_number(:saturday) || day == symbol_to_number(:sunday)
+  end
+
+  def is_weekday?(day)
+    !is_weekend?(day)
+  end
+
+  def symbol_to_number(sym)
+    lookup = {:sunday => 0, :monday => 1, :tuesday => 2, :wednesday => 3, :thursday => 4, :friday => 5, :saturday => 6}
+    lookup[sym] || raise("Invalid symbol specified")
+  end
+end

data/lib/chronic/repeaters/repeater_weekend.rb

@@ -1,9 +1,14 @@
 class Chronic::RepeaterWeekend < Chronic::Repeater #:nodoc:
   WEEKEND_SECONDS = 172_800 # (2 * 24 * 60 * 60)
-  
+
+  def initialize(type)
+    super
+    @current_week_start = nil
+  end
+
   def next(pointer)
     super
-    
+
     if !@current_week_start
       case pointer
       when :future
@@ -21,13 +26,13 @@ class Chronic::RepeaterWeekend < Chronic::Repeater #:nodoc:
       direction = pointer == :future ? 1 : -1
       @current_week_start += direction * Chronic::RepeaterWeek::WEEK_SECONDS
     end
-    
+
     Chronic::Span.new(@current_week_start, @current_week_start + WEEKEND_SECONDS)
   end
-  
+
   def this(pointer = :future)
     super
-    
+
     case pointer
     when :future, :none
       saturday_repeater = Chronic::RepeaterDayName.new(:saturday)
@@ -41,7 +46,7 @@ class Chronic::RepeaterWeekend < Chronic::Repeater #:nodoc:
       Chronic::Span.new(last_saturday_span.begin, last_saturday_span.begin + WEEKEND_SECONDS)
     end
   end
-  
+
   def offset(span, amount, pointer)
     direction = pointer == :future ? 1 : -1
     weekend = Chronic::RepeaterWeekend.new(:weekend)
@@ -49,12 +54,12 @@ class Chronic::RepeaterWeekend < Chronic::Repeater #:nodoc:
     start = weekend.next(pointer).begin + (amount - 1) * direction * Chronic::RepeaterWeek::WEEK_SECONDS
     Chronic::Span.new(start, start + (span.end - span.begin))
   end
-  
+
   def width
     WEEKEND_SECONDS
   end
-  
+
   def to_s
     super << '-weekend'
   end
-end
+end

data/lib/chronic/repeaters/repeater_year.rb

@@ -1,58 +1,64 @@
 class Chronic::RepeaterYear < Chronic::Repeater #:nodoc:
-  
+  YEAR_SECONDS =  31536000  # 365 * 24 * 60 * 60
+
+  def initialize(type)
+    super
+    @current_year_start = nil
+  end
+
   def next(pointer)
     super
-    
+
     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)
     super
-    
+
     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)
   end
-  
+
   def offset(span, amount, pointer)
     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
-  
+
   def width
     (365 * 24 * 60 * 60)
   end
-  
+
   def to_s
     super << '-year'
   end
-end
+end

data/lib/chronic/scalar.rb

@@ -11,7 +11,7 @@ module Chronic
       end
       tokens
     end
-  
+
     def self.scan_for_scalars(token, post_token)
       if token.word =~ /^\d*$/
         unless post_token && %w{am pm morning afternoon evening night}.include?(post_token)
@@ -20,55 +20,57 @@ module Chronic
       end
       return nil
     end
-    
+
     def self.scan_for_days(token, post_token)
       if token.word =~ /^\d\d?$/
-        unless token.word.to_i > 31 || (post_token && %w{am pm morning afternoon evening night}.include?(post_token))
-          return ScalarDay.new(token.word.to_i)
+        toi = token.word.to_i
+        unless toi > 31 || toi < 1 || (post_token && %w{am pm morning afternoon evening night}.include?(post_token.word))
+          return ScalarDay.new(toi)
         end
       end
       return nil
     end
-    
+
     def self.scan_for_months(token, post_token)
       if token.word =~ /^\d\d?$/
-        unless token.word.to_i > 12 || (post_token && %w{am pm morning afternoon evening night}.include?(post_token))
-          return ScalarMonth.new(token.word.to_i)
+        toi = token.word.to_i
+        unless toi > 12 || toi < 1 || (post_token && %w{am pm morning afternoon evening night}.include?(post_token.word))
+          return ScalarMonth.new(toi)
         end
       end
       return nil
     end
-    
+
     def self.scan_for_years(token, post_token)
       if token.word =~ /^([1-9]\d)?\d\d?$/
-        unless post_token && %w{am pm morning afternoon evening night}.include?(post_token)
+        unless post_token && %w{am pm morning afternoon evening night}.include?(post_token.word)
           return ScalarYear.new(token.word.to_i)
         end
       end
       return nil
     end
-    
+
     def to_s
       'scalar'
     end
   end
-  
+
   class ScalarDay < Scalar #:nodoc:
     def to_s
       super << '-day-' << @type.to_s
     end
   end
-  
+
   class ScalarMonth < Scalar #:nodoc:
     def to_s
       super << '-month-' << @type.to_s
     end
   end
-  
+
   class ScalarYear < Scalar #:nodoc:
     def to_s
       super << '-year-' << @type.to_s
     end
   end
 
-end
+end

data/lib/chronic/separator.rb

@@ -7,10 +7,11 @@ module Chronic
         if t = self.scan_for_slash_or_dash(tokens[i]) then tokens[i].tag(t); next end
         if t = self.scan_for_at(tokens[i]) then tokens[i].tag(t); next end
         if t = self.scan_for_in(tokens[i]) then tokens[i].tag(t); next end
+        if t = self.scan_for_on(tokens[i]) then tokens[i].tag(t); next end
       end
       tokens
     end
-    
+
     def self.scan_for_commas(token)
       scanner = {/^,$/ => :comma}
       scanner.keys.each do |scanner_item|
@@ -18,7 +19,7 @@ module Chronic
       end
       return nil
     end
-    
+
     def self.scan_for_slash_or_dash(token)
       scanner = {/^-$/ => :dash,
                  /^\/$/ => :slash}
@@ -27,7 +28,7 @@ module Chronic
       end
       return nil
     end
-    
+
     def self.scan_for_at(token)
       scanner = {/^(at|@)$/ => :at}
       scanner.keys.each do |scanner_item|
@@ -35,7 +36,7 @@ module Chronic
       end
       return nil
     end
-    
+
     def self.scan_for_in(token)
       scanner = {/^in$/ => :in}
       scanner.keys.each do |scanner_item|
@@ -43,34 +44,48 @@ module Chronic
       end
       return nil
     end
-    
+
+    def self.scan_for_on(token)
+      scanner = {/^on$/ => :on}
+      scanner.keys.each do |scanner_item|
+        return SeparatorOn.new(scanner[scanner_item]) if scanner_item =~ token.word
+      end
+      return nil
+    end
+
     def to_s
       'separator'
     end
   end
-  
+
   class SeparatorComma < Separator #:nodoc:
     def to_s
       super << '-comma'
     end
   end
-  
+
   class SeparatorSlashOrDash < Separator #:nodoc:
     def to_s
       super << '-slashordash-' << @type.to_s
     end
   end
-  
+
   class SeparatorAt < Separator #:nodoc:
     def to_s
       super << '-at'
     end
   end
-  
+
   class SeparatorIn < Separator #:nodoc:
     def to_s
       super << '-in'
     end
   end
 
-end
+  class SeparatorOn < Separator #:nodoc:
+    def to_s
+      super << '-on'
+    end
+  end
+
+end

data/lib/chronic/time_zone.rb

@@ -0,0 +1,23 @@
+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,
+                 /(tzminus)?\d{4}/ => :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

@@ -9,6 +9,8 @@
 
 $:.unshift File.dirname(__FILE__)     # For use/testing when no gem is installed
 
+require 'time'
+
 require 'chronic/chronic'
 require 'chronic/handlers'
 
@@ -21,6 +23,7 @@ require 'chronic/repeaters/repeater_month_name'
 require 'chronic/repeaters/repeater_fortnight'
 require 'chronic/repeaters/repeater_week'
 require 'chronic/repeaters/repeater_weekend'
+require 'chronic/repeaters/repeater_weekday'
 require 'chronic/repeaters/repeater_day'
 require 'chronic/repeaters/repeater_day_name'
 require 'chronic/repeaters/repeater_day_portion'
@@ -34,39 +37,91 @@ require 'chronic/pointer'
 require 'chronic/scalar'
 require 'chronic/ordinal'
 require 'chronic/separator'
+require 'chronic/time_zone'
 
-require 'numerizer/numerizer'
+require 'chronic/numerizer/numerizer'
 
 module Chronic
-  VERSION = "0.2.0"
-  
-  def self.debug; false; end
-end
+  VERSION = "0.3.0"
 
-alias p_orig p
+  class << self
+    attr_accessor :debug
+    attr_accessor :time_class
+  end
 
-def p(val)
-  p_orig val
-  puts
+  self.debug = false
+  self.time_class = Time
 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
-    
-    Time.local(year, month, day, hour, minute, second)
+
+    # 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
+
+    Chronic.time_class.local(year, month, day, hour, minute, second)
   end
-end
+end

data/test/helper.rb

@@ -0,0 +1,7 @@
+require 'test/unit'
+
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift(File.join(dir, '..', 'lib'))
+$LOAD_PATH.unshift(dir)
+
+require 'chronic'

data/test/test_Chronic.rb

@@ -1,50 +1,49 @@
-require 'chronic'
-require 'test/unit'
+require File.join(File.dirname(__FILE__), *%w[helper])
 
 class TestChronic < 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_post_normalize_am_pm_aliases
     # affect wanted patterns
-    
+
     tokens = [Chronic::Token.new("5:00"), Chronic::Token.new("morning")]
     tokens[0].tag(Chronic::RepeaterTime.new("5:00"))
     tokens[1].tag(Chronic::RepeaterDayPortion.new(:morning))
-    
+
     assert_equal :morning, tokens[1].tags[0].type
-    
+
     tokens = Chronic.dealias_and_disambiguate_times(tokens, {})
-    
+
     assert_equal :am, tokens[1].tags[0].type
     assert_equal 2, tokens.size
-    
+
     # don't affect unwanted patterns
-    
+
     tokens = [Chronic::Token.new("friday"), Chronic::Token.new("morning")]
     tokens[0].tag(Chronic::RepeaterDayName.new(:friday))
     tokens[1].tag(Chronic::RepeaterDayPortion.new(:morning))
-    
+
     assert_equal :morning, tokens[1].tags[0].type
-    
+
     tokens = Chronic.dealias_and_disambiguate_times(tokens, {})
-    
+
     assert_equal :morning, tokens[1].tags[0].type
     assert_equal 2, tokens.size
   end
-  
+
   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)
-    
+
     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)
-    
+
     span = Chronic::Span.new(Time.local(2006, 11), Time.local(2006, 12))
     assert_equal Time.local(2006, 11, 16), Chronic.guess(span)
   end
-  
-end
+
+end