chronic 0.2.2 → 0.3.0

data/lib/chronic/repeaters/repeater_season.rb

@@ -1,23 +1,150 @@
+class Time
+  def to_minidate
+    MiniDate.new(self.month, self.day)
+  end
+end
+
+class Season
+  attr_reader :start, :end
+
+  def initialize(myStart, myEnd)
+    @start = myStart
+    @end = myEnd
+  end
+
+  def self.find_next_season(season, pointer)
+    lookup = {:spring => 0, :summer => 1, :autumn => 2, :winter => 3}
+    next_season_num = (lookup[season]+1*pointer) % 4
+    lookup.invert[next_season_num]
+  end
+
+  def self.season_after(season); find_next_season(season, +1); end
+  def self.season_before(season); find_next_season(season, -1); end
+end
+
+class MiniDate
+  attr_accessor :month, :day
+
+  def initialize(month, day)
+    @month = month
+    @day = day
+  end
+
+  def is_between?(md_start, md_end)
+    return true if (@month == md_start.month and @day >= md_start.day) ||
+                   (@month == md_end.month and @day <= md_end.day)
+
+    i = md_start.month + 1
+    until i == md_end.month
+      return true if @month == i
+      i = (i+1) % 12
+    end
+
+    return false
+  end
+
+  def equals?(other)
+    @month == other.month and day == other.day
+  end
+end
+
 class Chronic::RepeaterSeason < Chronic::Repeater #:nodoc:
+  YEAR_SEASONS = 4
   SEASON_SECONDS = 7_862_400 # 91 * 24 * 60 * 60
-  
+  SEASONS = { :spring => Season.new( MiniDate.new(3,20),MiniDate.new(6,20) ),
+              :summer => Season.new( MiniDate.new(6,21),MiniDate.new(9,22) ),
+              :autumn => Season.new( MiniDate.new(9,23),MiniDate.new(12,21) ),
+              :winter => Season.new( MiniDate.new(12,22),MiniDate.new(3,19) ) }
+
+  def initialize(type)
+    super
+    @next_season_start = nil
+  end
+
   def next(pointer)
     super
-    
-    raise 'Not implemented'
+
+    direction = pointer == :future ? 1 : -1
+    next_season = Season.find_next_season(find_current_season(@now.to_minidate), direction)
+
+    find_next_season_span(direction, next_season)
   end
-  
+
   def this(pointer = :future)
     super
-    
-    raise 'Not implemented'
+
+    direction = pointer == :future ? 1 : -1
+
+    today = Time.construct(@now.year, @now.month, @now.day)
+    this_ssn = find_current_season(@now.to_minidate)
+    case pointer
+    when :past
+      this_ssn_start = today + direction * num_seconds_til_start(this_ssn, direction)
+      this_ssn_end = today
+    when :future
+      this_ssn_start = today + Chronic::RepeaterDay::DAY_SECONDS
+      this_ssn_end = today + direction * num_seconds_til_end(this_ssn, direction)
+    when :none
+      this_ssn_start = today + direction * num_seconds_til_start(this_ssn, direction)
+      this_ssn_end = today + direction * num_seconds_til_end(this_ssn, direction)
+    end
+
+    Chronic::Span.new(this_ssn_start, this_ssn_end)
   end
-  
+
+  def offset(span, amount, pointer)
+    Chronic::Span.new(offset_by(span.begin, amount, pointer), offset_by(span.end, amount, pointer))
+  end
+
+  def offset_by(time, amount, pointer)
+    direction = pointer == :future ? 1 : -1
+    time + amount * direction * SEASON_SECONDS
+  end
+
   def width
     SEASON_SECONDS
   end
-  
+
   def to_s
     super << '-season'
   end
-end
+
+  private
+
+  def find_next_season_span(direction, next_season)
+    if !@next_season_start or !@next_season_end
+      @next_season_start = Time.construct(@now.year, @now.month, @now.day)
+      @next_season_end = Time.construct(@now.year, @now.month, @now.day)
+    end
+
+    @next_season_start += direction * num_seconds_til_start(next_season, direction)
+    @next_season_end += direction * num_seconds_til_end(next_season, direction)
+
+    Chronic::Span.new(@next_season_start, @next_season_end)
+  end
+
+  def find_current_season(md)
+    [:spring, :summer, :autumn, :winter].each do |season|
+      return season if md.is_between?(SEASONS[season].start, SEASONS[season].end)
+    end
+  end
+
+  def num_seconds_til(goal, direction)
+    start = Time.construct(@now.year, @now.month, @now.day)
+    seconds = 0
+
+    until (start + direction * seconds).to_minidate.equals?(goal)
+      seconds += Chronic::RepeaterDay::DAY_SECONDS
+    end
+
+    seconds
+  end
+
+  def num_seconds_til_start(season_symbol, direction)
+    num_seconds_til(SEASONS[season_symbol].start, direction)
+  end
+
+  def num_seconds_til_end(season_symbol, direction)
+    num_seconds_til(SEASONS[season_symbol].end, direction)
+  end
+end

data/lib/chronic/repeaters/repeater_season_name.rb

@@ -1,24 +1,45 @@
+require 'chronic/repeaters/repeater_season.rb'
+
 class Chronic::RepeaterSeasonName < Chronic::RepeaterSeason #:nodoc:
-  @summer = ['jul 21', 'sep 22']
-  @autumn = ['sep 23', 'dec 21']
-  @winter = ['dec 22', 'mar 19']
-  @spring = ['mar 20', 'jul 20']
-  
+  SEASON_SECONDS = 7_862_400 # 91 * 24 * 60 * 60
+  DAY_SECONDS = 86_400 # (24 * 60 * 60)
+
   def next(pointer)
-    super
-    raise 'Not implemented'
+    direction = pointer == :future ? 1 : -1
+    find_next_season_span(direction, @type)
   end
-  
+
   def this(pointer = :future)
-    super
-    raise 'Not implemented'
+    # super
+
+    direction = pointer == :future ? 1 : -1
+
+    today = Time.construct(@now.year, @now.month, @now.day)
+    goal_ssn_start = today + direction * num_seconds_til_start(@type, direction)
+    goal_ssn_end = today + direction * num_seconds_til_end(@type, direction)
+    curr_ssn = find_current_season(@now.to_minidate)
+    case pointer
+    when :past
+      this_ssn_start = goal_ssn_start
+      this_ssn_end = (curr_ssn == @type) ? today : goal_ssn_end
+    when :future
+      this_ssn_start = (curr_ssn == @type) ? today + Chronic::RepeaterDay::DAY_SECONDS : goal_ssn_start
+      this_ssn_end = goal_ssn_end
+    when :none
+      this_ssn_start = goal_ssn_start
+      this_ssn_end = goal_ssn_end
+    end
+
+    Chronic::Span.new(this_ssn_start, this_ssn_end)
   end
-  
-  def width
-    (91 * 24 * 60 * 60)
+
+  def offset(span, amount, pointer)
+    Chronic::Span.new(offset_by(span.begin, amount, pointer), offset_by(span.end, amount, pointer))
   end
-  
-  def to_s
-    super << '-season-' << @type.to_s
+
+  def offset_by(time, amount, pointer)
+    direction = pointer == :future ? 1 : -1
+    time + amount * direction * Chronic::RepeaterYear::YEAR_SECONDS
   end
-end
+
+end

data/lib/chronic/repeaters/repeater_second.rb

@@ -1,36 +1,41 @@
 class Chronic::RepeaterSecond < Chronic::Repeater #:nodoc:
   SECOND_SECONDS = 1 # haha, awesome
-  
+
+  def initialize(type)
+    super
+    @second_start = nil
+  end
+
   def next(pointer = :future)
     super
-    
+
     direction = pointer == :future ? 1 : -1
-    
+
     if !@second_start
       @second_start = @now + (direction * SECOND_SECONDS)
     else
       @second_start += SECOND_SECONDS * direction
     end
-    
+
     Chronic::Span.new(@second_start, @second_start + SECOND_SECONDS)
   end
-  
+
   def this(pointer = :future)
     super
-    
+
     Chronic::Span.new(@now, @now + 1)
   end
-  
+
   def offset(span, amount, pointer)
     direction = pointer == :future ? 1 : -1
     span + direction * amount * SECOND_SECONDS
   end
-  
+
   def width
     SECOND_SECONDS
   end
-  
+
   def to_s
     super << '-second'
   end
-end
+end

data/lib/chronic/repeaters/repeater_time.rb

@@ -1,114 +1,124 @@
 class Chronic::RepeaterTime < Chronic::Repeater #:nodoc:
   class Tick #:nodoc:
     attr_accessor :time
-    
+
     def initialize(time, ambiguous = false)
       @time = time
       @ambiguous = ambiguous
     end
-    
+
     def ambiguous?
       @ambiguous
     end
-    
+
     def *(other)
       Tick.new(@time * other, @ambiguous)
     end
-    
+
     def to_f
       @time.to_f
     end
-    
+
     def to_s
       @time.to_s + (@ambiguous ? '?' : '')
     end
   end
-  
+
   def initialize(time, options = {})
+    @current_time = nil
     t = time.gsub(/\:/, '')
-    @type = 
-    if (1..2) === t.size
-      Tick.new(t.to_i * 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)
-    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)
-    else
-      raise("Time cannot exceed six digits")
+
+    @type =
+    case t.size
+      when 1..2
+        hours = t.to_i
+        hours == 12 ? Tick.new(0 * 60 * 60, true) : Tick.new(hours * 60 * 60, true)
+      when 3
+        Tick.new((t[0..0].to_i * 60 * 60) + (t[1..2].to_i * 60), true)
+      when 4
+        ambiguous = time =~ /:/ && t[0..0].to_i != 0 && t[0..1].to_i <= 12
+        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)
+      when 5
+        Tick.new(t[0..0].to_i * 60 * 60 + t[1..2].to_i * 60 + t[3..4].to_i, true)
+      when 6
+        ambiguous = time =~ /:/ && t[0..0].to_i != 0 && t[0..1].to_i <= 12
+        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
   end
-  
+
   # Return the next past or future Span for the time that this Repeater represents
   #   pointer - Symbol representing which temporal direction to fetch the next day
   #             must be either :past or :future
   def next(pointer)
     super
-    
+
     half_day = 60 * 60 * 12
     full_day = 60 * 60 * 24
-    
+
     first = false
-    
+
     unless @current_time
       first = true
-      midnight = Time.local(@now.year, @now.month, @now.day)
+      midnight = Chronic.time_class.local(@now.year, @now.month, @now.day)
+
       yesterday_midnight = midnight - full_day
       tomorrow_midnight = midnight + full_day
 
+      offset_fix = midnight.gmt_offset - tomorrow_midnight.gmt_offset
+      tomorrow_midnight += offset_fix
+
       catch :done do
         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
+            [midnight + @type + offset_fix, midnight + half_day + @type + offset_fix, tomorrow_midnight + @type].each do |t|
+              (@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
+            [midnight + @type + offset_fix, tomorrow_midnight + @type].each do |t|
+              (@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
+            [midnight + half_day + @type + offset_fix, midnight + @type + offset_fix, yesterday_midnight + @type + half_day].each do |t|
+              (@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
+            [midnight + @type + offset_fix, yesterday_midnight + @type].each do |t|
+              (@current_time = t; throw :done) if t <= @now
             end
           end
         end
       end
-      
+
       @current_time || raise("Current time cannot be nil at this point")
     end
-    
+
     unless first
       increment = @type.ambiguous? ? half_day : full_day
       @current_time += pointer == :future ? increment : -increment
     end
-    
+
     Chronic::Span.new(@current_time, @current_time + width)
   end
-  
+
   def this(context = :future)
     super
-    
+
     context = :future if context == :none
-    
+
     self.next(context)
   end
-  
+
   def width
     1
   end
-  
+
   def to_s
     super << '-time-' << @type.to_s
   end
-end
+end

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