chronic 0.1.5 → 0.6.5

data/lib/chronic/repeaters/repeater_time.rb

@@ -1,114 +1,128 @@
-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 ? '?' : '')
+module Chronic
+  class RepeaterTime < 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
-  end
-  
-  def initialize(time, options = {})
-    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")
+
+    def initialize(time)
+      t = time.gsub(/\:/, '')
+
+      @type =
+      case t.size
+      when 1..2
+        hours = t.to_i
+        Tick.new((hours == 12 ? 0 : hours) * 60 * 60, true)
+      when 3
+        hours = t[0..0].to_i
+        ambiguous = hours > 0
+        Tick.new((hours * 60 * 60) + (t[1..2].to_i * 60), ambiguous)
+      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
-  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)
-      yesterday_midnight = midnight - full_day
-      tomorrow_midnight = midnight + full_day
-
-      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
-            end
-          else
-            [midnight + @type, 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
+
+    # 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 = 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.time + offset_fix, midnight + half_day + @type.time + offset_fix, tomorrow_midnight + @type.time].each do |t|
+                (@current_time = t; throw :done) if t >= @now
+              end
+            else
+              [midnight + @type.time + offset_fix, tomorrow_midnight + @type.time].each do |t|
+                (@current_time = t; throw :done) if t >= @now
+              end
             end
-          else
-            [midnight + @type, yesterday_midnight + @type].each do |t|
-              (@current_time = t; throw :done) if t < @now
+          else # pointer == :past
+            if @type.ambiguous?
+              [midnight + half_day + @type.time + offset_fix, midnight + @type.time + offset_fix, yesterday_midnight + @type.time + half_day].each do |t|
+                (@current_time = t; throw :done) if t <= @now
+              end
+            else
+              [midnight + @type.time + offset_fix, yesterday_midnight + @type.time].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
-      
-      @current_time || raise("Current time cannot be nil at this point")
+
+      unless first
+        increment = @type.ambiguous? ? half_day : full_day
+        @current_time += pointer == :future ? increment : -increment
+      end
+
+      Span.new(@current_time, @current_time + width)
     end
-    
-    unless first
-      increment = @type.ambiguous? ? half_day : full_day
-      @current_time += pointer == :future ? increment : -increment
+
+    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
-    
-    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

data/lib/chronic/repeaters/repeater_week.rb

@@ -1,68 +1,74 @@
-class Chronic::RepeaterWeek < Chronic::Repeater #:nodoc:
-  WEEK_SECONDS = 604800 # (7 * 24 * 60 * 60)
-  
-  def next(pointer)
-    super
-    
-    if !@current_week_start
+module Chronic
+  class RepeaterWeek < Repeater #:nodoc:
+    WEEK_SECONDS = 604800 # (7 * 24 * 60 * 60)
+
+    def initialize(type)
+      super
+    end
+
+    def next(pointer)
+      super
+
+      if !@current_week_start
+        case pointer
+        when :future
+          sunday_repeater = RepeaterDayName.new(:sunday)
+          sunday_repeater.start = @now
+          next_sunday_span = sunday_repeater.next(:future)
+          @current_week_start = next_sunday_span.begin
+        when :past
+          sunday_repeater = RepeaterDayName.new(:sunday)
+          sunday_repeater.start = (@now + RepeaterDay::DAY_SECONDS)
+          sunday_repeater.next(:past)
+          last_sunday_span = sunday_repeater.next(:past)
+          @current_week_start = last_sunday_span.begin
+        end
+      else
+        direction = pointer == :future ? 1 : -1
+        @current_week_start += direction * WEEK_SECONDS
+      end
+
+      Span.new(@current_week_start, @current_week_start + WEEK_SECONDS)
+    end
+
+    def this(pointer = :future)
+      super
+
       case pointer
       when :future
-        sunday_repeater = Chronic::RepeaterDayName.new(:sunday)
+        this_week_start = Chronic.time_class.local(@now.year, @now.month, @now.day, @now.hour) + RepeaterHour::HOUR_SECONDS
+        sunday_repeater = RepeaterDayName.new(:sunday)
         sunday_repeater.start = @now
-        next_sunday_span = sunday_repeater.next(:future)
-        @current_week_start = next_sunday_span.begin
+        this_sunday_span = sunday_repeater.this(:future)
+        this_week_end = this_sunday_span.begin
+        Span.new(this_week_start, this_week_end)
       when :past
-        sunday_repeater = Chronic::RepeaterDayName.new(:sunday)
-        sunday_repeater.start = (@now + Chronic::RepeaterDay::DAY_SECONDS)
-        sunday_repeater.next(:past)
+        this_week_end = Chronic.time_class.local(@now.year, @now.month, @now.day, @now.hour)
+        sunday_repeater = RepeaterDayName.new(:sunday)
+        sunday_repeater.start = @now
+        last_sunday_span = sunday_repeater.next(:past)
+        this_week_start = last_sunday_span.begin
+        Span.new(this_week_start, this_week_end)
+      when :none
+        sunday_repeater = RepeaterDayName.new(:sunday)
+        sunday_repeater.start = @now
         last_sunday_span = sunday_repeater.next(:past)
-        @current_week_start = last_sunday_span.begin
+        this_week_start = last_sunday_span.begin
+        Span.new(this_week_start, this_week_start + WEEK_SECONDS)
       end
-    else
+    end
+
+    def offset(span, amount, pointer)
       direction = pointer == :future ? 1 : -1
-      @current_week_start += direction * WEEK_SECONDS
+      span + direction * amount * 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
-      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)
-      sunday_repeater = Chronic::RepeaterDayName.new(:sunday)
-      sunday_repeater.start = @now
-      last_sunday_span = sunday_repeater.next(:past)
-      this_week_start = last_sunday_span.begin
-      Chronic::Span.new(this_week_start, this_week_end)
-    when :none
-      sunday_repeater = Chronic::RepeaterDayName.new(:sunday)
-      sunday_repeater.start = @now
-      last_sunday_span = sunday_repeater.next(:past)
-      this_week_start = last_sunday_span.begin
-      Chronic::Span.new(this_week_start, this_week_start + WEEK_SECONDS)
+
+    def width
+      WEEK_SECONDS
+    end
+
+    def to_s
+      super << '-week'
     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

data/lib/chronic/repeaters/repeater_weekday.rb

@@ -0,0 +1,85 @@
+module Chronic
+  class RepeaterWeekday < Repeater #:nodoc:
+    DAY_SECONDS = 86400 # (24 * 60 * 60)
+    DAYS = {
+      :sunday => 0,
+      :monday => 1,
+      :tuesday => 2,
+      :wednesday => 3,
+      :thursday => 4,
+      :friday => 5,
+      :saturday => 6
+    }
+
+    def initialize(type)
+      super
+    end
+
+    def next(pointer)
+      super
+
+      direction = pointer == :future ? 1 : -1
+
+      if !@current_weekday_start
+        @current_weekday_start = Chronic.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
+
+      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)
+      DAYS[sym] || raise("Invalid symbol specified")
+    end
+  end
+end

data/lib/chronic/repeaters/repeater_weekend.rb

@@ -1,11 +1,66 @@
-class Chronic::RepeaterWeekend < Chronic::Repeater #:nodoc:
-  WEEKEND_SECONDS = 172_800 # (2 * 24 * 60 * 60)
-  
-  def width
-    WEEKEND_SECONDS
-  end
-  
-  def to_s
-    super << '-weekend'
+module Chronic
+  class RepeaterWeekend < Repeater #:nodoc:
+    WEEKEND_SECONDS = 172_800 # (2 * 24 * 60 * 60)
+
+    def initialize(type)
+      super
+    end
+
+    def next(pointer)
+      super
+
+      if !@current_week_start
+        case pointer
+        when :future
+          saturday_repeater = RepeaterDayName.new(:saturday)
+          saturday_repeater.start = @now
+          next_saturday_span = saturday_repeater.next(:future)
+          @current_week_start = next_saturday_span.begin
+        when :past
+          saturday_repeater = RepeaterDayName.new(:saturday)
+          saturday_repeater.start = (@now + RepeaterDay::DAY_SECONDS)
+          last_saturday_span = saturday_repeater.next(:past)
+          @current_week_start = last_saturday_span.begin
+        end
+      else
+        direction = pointer == :future ? 1 : -1
+        @current_week_start += direction * RepeaterWeek::WEEK_SECONDS
+      end
+
+      Span.new(@current_week_start, @current_week_start + WEEKEND_SECONDS)
+    end
+
+    def this(pointer = :future)
+      super
+
+      case pointer
+      when :future, :none
+        saturday_repeater = RepeaterDayName.new(:saturday)
+        saturday_repeater.start = @now
+        this_saturday_span = saturday_repeater.this(:future)
+        Span.new(this_saturday_span.begin, this_saturday_span.begin + WEEKEND_SECONDS)
+      when :past
+        saturday_repeater = RepeaterDayName.new(:saturday)
+        saturday_repeater.start = @now
+        last_saturday_span = saturday_repeater.this(:past)
+        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 = RepeaterWeekend.new(:weekend)
+      weekend.start = span.begin
+      start = weekend.next(pointer).begin + (amount - 1) * direction * RepeaterWeek::WEEK_SECONDS
+      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,77 @@
-class Chronic::RepeaterYear < Chronic::Repeater #:nodoc:
-  
-  def next(pointer)
-    super
-    
-    if !@current_year_start
+module Chronic
+  class RepeaterYear < Repeater #:nodoc:
+    YEAR_SECONDS =  31536000  # 365 * 24 * 60 * 60
+
+    def initialize(type)
+      super
+    end
+
+    def next(pointer)
+      super
+
+      if !@current_year_start
+        case pointer
+        when :future
+          @current_year_start = Chronic.construct(@now.year + 1)
+        when :past
+          @current_year_start = Chronic.construct(@now.year - 1)
+        end
+      else
+        diff = pointer == :future ? 1 : -1
+        @current_year_start = Chronic.construct(@current_year_start.year + diff)
+      end
+
+      Span.new(@current_year_start, Chronic.construct(@current_year_start.year + 1))
+    end
+
+    def this(pointer = :future)
+      super
+
       case pointer
       when :future
-        @current_year_start = Time.local(@now.year + 1)
+        this_year_start = Chronic.construct(@now.year, @now.month, @now.day + 1)
+        this_year_end = Chronic.construct(@now.year + 1, 1, 1)
       when :past
-        @current_year_start = Time.local(@now.year - 1)
+        this_year_start = Chronic.construct(@now.year, 1, 1)
+        this_year_end = Chronic.construct(@now.year, @now.month, @now.day)
+      when :none
+        this_year_start = Chronic.construct(@now.year, 1, 1)
+        this_year_end = Chronic.construct(@now.year + 1, 1, 1)
+      end
+
+      Span.new(this_year_start, this_year_end)
+    end
+
+    def offset(span, amount, pointer)
+      direction = pointer == :future ? 1 : -1
+      new_begin = build_offset_time(span.begin, amount, direction)
+      new_end   = build_offset_time(span.end, amount, direction)
+      Span.new(new_begin, new_end)
+    end
+
+    def width
+      YEAR_SECONDS
+    end
+
+    def to_s
+      super << '-year'
+    end
+
+    private
+
+    def build_offset_time(time, amount, direction)
+      year = time.year + (amount * direction)
+      days = month_days(year, time.month)
+      day = time.day > days ? days : time.day
+      Chronic.construct(year, time.month, day, time.hour, time.min, time.sec)
+    end
+
+    def month_days(year, month)
+      if Date.leap?(year)
+        RepeaterMonth::MONTH_DAYS_LEAP[month - 1]
+      else
+        RepeaterMonth::MONTH_DAYS[month - 1]
       end
-    else
-      diff = pointer == :future ? 1 : -1
-      @current_year_start = Time.local(@current_year_start.year + diff)
     end
-    
-    Chronic::Span.new(@current_year_start, Time.local(@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)
-    when :past
-      this_year_start = Time.local(@now.year, 1, 1)
-      this_year_end = Time.local(@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)
-    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)
-    
-    se = span.end
-    new_end = Time.local(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