Fix first weekly occurrences with non-Sunday week start

lib/ice_cube/rule.rb

@@ -11,6 +11,9 @@ class Rule
 
     attr_reader :uses
 
+    def reset
+    end
+
     # Is this a terminating schedule?
     def terminating?
       until_time || occurrence_count
@@ -51,11 +54,6 @@ def to_hash
       raise MethodNotImplemented, "Expected to be overridden by subclasses"
     end
 
-    # Reset the uses on the rule to 0
-    def reset
-      @uses = 0
-    end
-
     def next_time(time, schedule, closing_time)
     end
 

lib/ice_cube/rules/daily_rule.rb

@@ -4,7 +4,7 @@ class DailyRule < ValidatedRule
 
     include Validations::DailyInterval
 
-    def initialize(interval = 1, week_start = :sunday)
+    def initialize(interval = 1)
       super
       interval(interval)
       schedule_lock(:hour, :min, :sec)

lib/ice_cube/rules/hourly_rule.rb

@@ -4,7 +4,7 @@ class HourlyRule < ValidatedRule
 
     include Validations::HourlyInterval
 
-    def initialize(interval = 1, week_start = :sunday)
+    def initialize(interval = 1)
       super
       interval(interval)
       schedule_lock(:min, :sec)

lib/ice_cube/rules/minutely_rule.rb

@@ -4,7 +4,7 @@ class MinutelyRule < ValidatedRule
 
     include Validations::MinutelyInterval
 
-    def initialize(interval = 1, week_start = :sunday)
+    def initialize(interval = 1)
       super
       interval(interval)
       schedule_lock(:sec)

lib/ice_cube/rules/monthly_rule.rb

@@ -4,7 +4,7 @@ class MonthlyRule < ValidatedRule
 
     include Validations::MonthlyInterval
 
-    def initialize(interval = 1, week_start = :sunday)
+    def initialize(interval = 1)
       super
       interval(interval)
       schedule_lock(:day, :hour, :min, :sec)

lib/ice_cube/rules/secondly_rule.rb

@@ -4,7 +4,7 @@ class SecondlyRule < ValidatedRule
 
     include Validations::SecondlyInterval
 
-    def initialize(interval = 1, week_start = :sunday)
+    def initialize(interval = 1)
       super
       interval(interval)
       reset

lib/ice_cube/rules/weekly_rule.rb

@@ -4,13 +4,39 @@ class WeeklyRule < ValidatedRule
 
     include Validations::WeeklyInterval
 
+    attr_reader :week_start
+
     def initialize(interval = 1, week_start = :sunday)
-      super
+      super(interval)
       interval(interval, week_start)
       schedule_lock(:wday, :hour, :min, :sec)
       reset
     end
 
+    # Calculate the effective start time for when the given start time is later
+    # in the week than one of the weekday validations, such that times could be
+    # missed by a 7-day jump using the weekly interval, or when selecting from a
+    # date that is misaligned from the schedule interval.
+    #
+    def realign(step_time, start_time)
+      time = TimeUtil::TimeWrapper.new(start_time)
+      offset = wday_offset(step_time, start_time)
+      time.add(:day, offset) if offset
+      time.to_time
+    end
+
+    def wday_offset(step_time, start_time)
+      wday_validations = other_interval_validations.select { |v| v.type == :wday }
+      return if wday_validations.none?
+
+      days = (step_time - start_time).to_i / ONE_DAY
+      interval = base_interval_validation.validate(step_time, start_time).to_i
+      min_wday = TimeUtil.normalize_wday(wday_validations.min_by(&:day).day, week_start)
+      step_wday = TimeUtil.normalize_wday(step_time.wday, week_start)
+
+      days + interval - step_wday + min_wday
+    end
+
   end
 
 end

lib/ice_cube/rules/yearly_rule.rb

@@ -4,7 +4,7 @@ class YearlyRule < ValidatedRule
 
     include Validations::YearlyInterval
 
-    def initialize(interval = 1, week_start = :sunday)
+    def initialize(interval = 1)
       super
       interval(interval)
       schedule_lock(:month, :day, :hour, :min, :sec)

lib/ice_cube/schedule.rb

@@ -413,7 +413,7 @@ def enumerate_occurrences(opening_time, closing_time = nil, options = {}, &block
       spans = options[:spans] == true && duration != 0
       Enumerator.new do |yielder|
         reset
-        t1 = full_required? ? start_time : realign(opening_time) - (spans ? duration : 0)
+        t1 = full_required? ? start_time : opening_time - (spans ? duration : 0)
         loop do
           break unless (t0 = next_time(t1, closing_time))
           break if closing_time && t0 > closing_time
@@ -439,7 +439,7 @@ def next_time(time, closing_time)
       loop do
         min_time = recurrence_rules_with_implicit_start_occurrence.reduce(nil) do |min_time, rule|
           begin
-            new_time = rule.next_time(time, self, min_time || closing_time)
+            new_time = rule.next_time(time, start_time, min_time || closing_time)
             [min_time, new_time].compact.min
           rescue StopIteration
             min_time
@@ -462,7 +462,7 @@ def full_required?
     # is excluded from the schedule
     def exception_time?(time)
       @all_exception_rules.any? do |rule|
-        rule.on?(time, self)
+        rule.on?(time, start_time)
       end
     end
 
@@ -502,28 +502,6 @@ def wind_back_dst
       end
     end
 
-    # If any rule has validations for values within the period, (overriding the
-    # interval from start time, e.g.  `day[_of_week]`), and the opening time is
-    # offset from the interval multiplier such that it might miss the first
-    # correct occurrence (e.g. repeat is every N weeks, but selecting from end
-    # of week N-1, the first jump would go to end of week N and miss any
-    # earlier validations in the week). This realigns the opening time to
-    # the start of the interval's correct period (e.g. move to start of week N)
-    # TODO: check if this is needed for validations other than `:wday`
-    #
-    def realign(opening_time)
-      time = TimeUtil::TimeWrapper.new(opening_time)
-      recurrence_rules.each do |rule|
-        wday_validations = rule.other_interval_validations.select { |v| v.type == :wday } or next
-        interval = rule.base_interval_validation.validate(opening_time, self).to_i
-        offset = wday_validations
-          .map { |v| v.validate(opening_time, self).to_i }
-          .reduce(0) { |least, i| i > 0 && i <= interval && (i < least || least == 0) ? i : least }
-        time.add(rule.base_interval_type, 7 - time.to_time.wday) if offset > 0
-      end
-      time.to_time
-    end
-
   end
 
 end

lib/ice_cube/single_occurrence_rule.rb

@@ -13,7 +13,7 @@ def terminating?
       true
     end
 
-    def next_time(t, schedule, closing_time)
+    def next_time(t, _, closing_time)
       unless closing_time && closing_time < t
         time if time.to_i >= t.to_i
       end

lib/ice_cube/validated_rule.rb

@@ -32,10 +32,17 @@ class ValidatedRule < Rule
 
     attr_reader :validations
 
-    def initialize(interval = 1, *)
+    def initialize(interval = 1)
       @validations = Hash.new
     end
 
+    # Reset the uses on the rule to 0
+    def reset
+      @time = nil
+      @start_time = nil
+      @uses = 0
+    end
+
     def base_interval_validation
       @validations[:interval].first
     end
@@ -49,17 +56,21 @@ def base_interval_type
     end
 
     # Compute the next time after (or including) the specified time in respect
-    # to the given schedule
-    def next_time(time, schedule, closing_time)
+    # to the given start time
+    def next_time(time, start_time, closing_time)
       @time = time
-      @schedule = schedule
+      @start_time ||= realign(time, start_time)
 
       return nil unless find_acceptable_time_before(closing_time)
 
       @uses += 1 if @time
       @time
     end
 
+    def realign(opening_time, start_time)
+      start_time
+    end
+
     def skipped_for_dst
       @uses -= 1 if @uses > 0
     end
@@ -145,7 +156,7 @@ def find_acceptable_time_before(boundary)
     #
     def validation_accepts_or_updates_time?(validations_for_type)
       res = validations_for_type.each_with_object([]) do |validation, offsets|
-        r = validation.validate(@time, @schedule)
+        r = validation.validate(@time, @start_time)
         return true if r.nil? || r == 0
         offsets << r
       end

lib/ice_cube/validations/count.rb

@@ -33,7 +33,7 @@ def dst_adjust?
         false
       end
 
-      def validate(time, schedule)
+      def validate(time, start_time)
         raise CountExceeded if rule.uses && rule.uses >= count
       end
 

lib/ice_cube/validations/daily_interval.rb

@@ -26,8 +26,8 @@ def dst_adjust?
         true
       end
 
-      def validate(step_time, schedule)
-        t0, t1 = schedule.start_time, step_time
+      def validate(step_time, start_time)
+        t0, t1 = start_time, step_time
         days = Date.new(t1.year, t1.month, t1.day) -
                Date.new(t0.year, t0.month, t0.day)
         offset = (days % interval).nonzero?

lib/ice_cube/validations/day_of_week.rb

@@ -30,7 +30,7 @@ def dst_adjust?
         true
       end
 
-      def validate(step_time, schedule)
+      def validate(step_time, start_time)
         wday = step_time.wday
         offset = (day < wday) ? (7 - wday + day) : (day - wday)
         wrapper = TimeUtil::TimeWrapper.new(step_time)

lib/ice_cube/validations/day_of_year.rb

@@ -29,7 +29,7 @@ def dst_adjust?
         true
       end
 
-      def validate(step_time, schedule)
+      def validate(step_time, start_time)
         days_in_year = TimeUtil.days_in_year(step_time)
         yday = day < 0 ? day + days_in_year + 1 : day
         offset = yday - step_time.yday

lib/ice_cube/validations/fixed_value.rb

@@ -12,11 +12,11 @@ class Validations::FixedValue
 
     INTERVALS = {:min => 60, :sec => 60, :hour => 24, :month => 12, :wday => 7}
 
-    def validate(time, schedule)
+    def validate(time, start_time)
       case type
-      when :day  then validate_day_lock(time, schedule)
-      when :hour then validate_hour_lock(time, schedule)
-      else validate_interval_lock(time, schedule)
+      when :day  then validate_day_lock(time, start_time)
+      when :hour then validate_hour_lock(time, start_time)
+      else validate_interval_lock(time, start_time)
       end
     end
 
@@ -25,17 +25,17 @@ def validate(time, schedule)
     # Validate if the current time unit matches the same unit from the schedule
     # start time, returning the difference to the interval
     #
-    def validate_interval_lock(time, schedule)
-      t0 = starting_unit(schedule.start_time)
+    def validate_interval_lock(time, start_time)
+      t0 = starting_unit(start_time)
       t1 = time.send(type)
       t0 >= t1 ? t0 - t1 : INTERVALS[type] - t1 + t0
     end
 
     # Lock the hour if explicitly set by hour_of_day, but allow for the nearest
     # hour during DST start to keep the correct interval.
     #
-    def validate_hour_lock(time, schedule)
-      h0 = starting_unit(schedule.start_time)
+    def validate_hour_lock(time, start_time)
+      h0 = starting_unit(start_time)
       h1 = time.hour
       if h0 >= h1
         h0 - h1
@@ -57,7 +57,7 @@ def validate_hour_lock(time, schedule)
     # Positive day values are taken literally so months with fewer days will
     # be skipped.
     #
-    def validate_day_lock(time, schedule)
+    def validate_day_lock(time, start_time)
       days_in_month = TimeUtil.days_in_month(time)
       date = Date.new(time.year, time.month, time.day)
 
@@ -68,7 +68,7 @@ def validate_day_lock(time, schedule)
         start = value
         month_overflow = 0
       else
-        start = TimeUtil.day_of_month(schedule.start_time.day, date)
+        start = TimeUtil.day_of_month(start_time.day, date)
         month_overflow = 0
       end
 

lib/ice_cube/validations/hourly_interval.rb

@@ -25,8 +25,8 @@ def dst_adjust?
         false
       end
 
-      def validate(step_time, schedule)
-        t0, t1 = schedule.start_time.to_i, step_time.to_i
+      def validate(step_time, start_time)
+        t0, t1 = start_time.to_i, step_time.to_i
         sec = (t1 - t1 % ONE_HOUR) -
               (t0 - t0 % ONE_HOUR)
         hours = sec / ONE_HOUR

lib/ice_cube/validations/lock.rb

@@ -12,11 +12,11 @@ module Validations::Lock
 
     INTERVALS = {:min => 60, :sec => 60, :hour => 24, :month => 12, :wday => 7}
 
-    def validate(time, schedule)
+    def validate(time, start_time)
       case type
-      when :day  then validate_day_lock(time, schedule)
-      when :hour then validate_hour_lock(time, schedule)
-      else validate_interval_lock(time, schedule)
+      when :day  then validate_day_lock(time, start_time)
+      when :hour then validate_hour_lock(time, start_time)
+      else validate_interval_lock(time, start_time)
       end
     end
 
@@ -25,17 +25,17 @@ def validate(time, schedule)
     # Validate if the current time unit matches the same unit from the schedule
     # start time, returning the difference to the interval
     #
-    def validate_interval_lock(time, schedule)
-      t0 = starting_unit(schedule.start_time)
+    def validate_interval_lock(time, start_time)
+      t0 = starting_unit(start_time)
       t1 = time.send(type)
       t0 >= t1 ? t0 - t1 : INTERVALS[type] - t1 + t0
     end
 
     # Lock the hour if explicitly set by hour_of_day, but allow for the nearest
     # hour during DST start to keep the correct interval.
     #
-    def validate_hour_lock(time, schedule)
-      h0 = starting_unit(schedule.start_time)
+    def validate_hour_lock(time, start_time)
+      h0 = starting_unit(start_time)
       h1 = time.hour
       if h0 >= h1
         h0 - h1
@@ -57,7 +57,7 @@ def validate_hour_lock(time, schedule)
     # Positive day values are taken literally so months with fewer days will
     # be skipped.
     #
-    def validate_day_lock(time, schedule)
+    def validate_day_lock(time, start_time)
       days_in_month = TimeUtil.days_in_month(time)
       date = Date.new(time.year, time.month, time.day)
 
@@ -68,7 +68,7 @@ def validate_day_lock(time, schedule)
         start = value
         month_overflow = 0
       else
-        start = TimeUtil.day_of_month(schedule.start_time.day, date)
+        start = TimeUtil.day_of_month(start_time.day, date)
         month_overflow = 0
       end