Prevent illogical rule combinations

lib/ice_cube/input_alignment.rb

@@ -0,0 +1,89 @@
+module IceCube
+  class InputAlignment
+
+    def initialize(rule, value, rule_part)
+      @rule = rule
+      @value = value
+      @rule_part = rule_part
+    end
+
+    attr_reader :rule, :value, :rule_part
+
+    def verify(freq, options={}, &block)
+      @rule.validations[:interval] or return
+
+      case @rule
+      when DailyRule
+        verify_wday_alignment(freq, &block)
+      when MonthlyRule
+        verify_month_alignment(freq, &block)
+      else
+        verify_freq_alignment(freq, &block)
+      end
+    end
+
+    private
+
+    def interval_validation
+      @interval_validation ||= @rule.validations[:interval].first
+    end
+
+    def interval_value
+      @interval_value ||= (rule_part == :interval) ? value : interval_validation.interval
+    end
+
+    def fixed_validations
+      @fixed_validations ||= @rule.validations.values.flatten.select { |v|
+        interval_type = (v.type == :wday ? :day : v.type)
+        v.class < Validations::FixedValue &&
+          interval_type == rule.base_interval_validation.type
+      }
+    end
+
+    def verify_freq_alignment(freq)
+      interval_validation.type == freq or return
+      (last_validation = fixed_validations.min_by(&:value)) or return
+
+      alignment = (value - last_validation.value) % interval_validation.interval
+      return if alignment.zero?
+
+      validation_values = fixed_validations.map(&:value).join(', ')
+      if rule_part == :interval
+        message = "interval(#{value}) " \
+                  "must be a multiple of " \
+                  "intervals in #{last_validation.key}(#{validation_values})"
+      else
+        message = "intervals in #{last_validation.key}(#{validation_values}, #{value}) " \
+                  "must be multiples of " \
+                  "interval(#{interval_validation.interval})"
+      end
+
+      yield ArgumentError.new(message)
+    end
+
+    def verify_month_alignment(_freq)
+      return if interval_value == 1 || (interval_value % 12).zero?
+      return if fixed_validations.empty?
+
+      message = "month_of_year can only be used with interval(1) or multiples of interval(12)"
+
+      yield ArgumentError.new(message)
+    end
+
+    def verify_wday_alignment(freq)
+      return if interval_value == 1
+
+      if freq == :wday
+        return if (interval_value % 7).zero?
+        return if Array(@rule.validations[:day]).empty?
+        message = "day can only be used with multiples of interval(7)"
+      else
+        (fixed_validation = fixed_validations.first) or return
+        message = "#{fixed_validation.key} can only be used with interval(1)"
+      end
+
+      yield ArgumentError.new(message)
+    end
+
+  end
+end

lib/ice_cube/rules/daily_rule.rb

@@ -2,6 +2,15 @@ module IceCube
 
   class DailyRule < ValidatedRule
 
+    include Validations::HourOfDay
+    include Validations::MinuteOfHour
+    include Validations::SecondOfMinute
+    include Validations::DayOfMonth
+    include Validations::DayOfWeek
+    include Validations::Day
+    include Validations::MonthOfYear
+    # include Validations::DayOfYear    # n/a
+
     include Validations::DailyInterval
 
     def initialize(interval = 1)

lib/ice_cube/rules/hourly_rule.rb

@@ -2,6 +2,15 @@ module IceCube
 
   class HourlyRule < ValidatedRule
 
+    include Validations::HourOfDay
+    include Validations::MinuteOfHour
+    include Validations::SecondOfMinute
+    include Validations::DayOfMonth
+    include Validations::DayOfWeek
+    include Validations::Day
+    include Validations::MonthOfYear
+    include Validations::DayOfYear
+
     include Validations::HourlyInterval
 
     def initialize(interval = 1)

lib/ice_cube/rules/minutely_rule.rb

@@ -2,6 +2,15 @@ module IceCube
 
   class MinutelyRule < ValidatedRule
 
+    include Validations::HourOfDay
+    include Validations::MinuteOfHour
+    include Validations::SecondOfMinute
+    include Validations::DayOfMonth
+    include Validations::DayOfWeek
+    include Validations::Day
+    include Validations::MonthOfYear
+    include Validations::DayOfYear
+
     include Validations::MinutelyInterval
 
     def initialize(interval = 1)

lib/ice_cube/rules/monthly_rule.rb

@@ -2,6 +2,15 @@ module IceCube
 
   class MonthlyRule < ValidatedRule
 
+    include Validations::HourOfDay
+    include Validations::MinuteOfHour
+    include Validations::SecondOfMinute
+    include Validations::DayOfMonth
+    include Validations::DayOfWeek
+    include Validations::Day
+    include Validations::MonthOfYear
+    # include Validations::DayOfYear    # n/a
+
     include Validations::MonthlyInterval
 
     def initialize(interval = 1)

lib/ice_cube/rules/secondly_rule.rb

@@ -2,6 +2,15 @@ module IceCube
 
   class SecondlyRule < ValidatedRule
 
+    include Validations::HourOfDay
+    include Validations::MinuteOfHour
+    include Validations::SecondOfMinute
+    include Validations::DayOfMonth
+    include Validations::DayOfWeek
+    include Validations::Day
+    include Validations::MonthOfYear
+    include Validations::DayOfYear
+
     include Validations::SecondlyInterval
 
     def initialize(interval = 1)

lib/ice_cube/rules/weekly_rule.rb

@@ -2,6 +2,15 @@ module IceCube
 
   class WeeklyRule < ValidatedRule
 
+    include Validations::HourOfDay
+    include Validations::MinuteOfHour
+    include Validations::SecondOfMinute
+    # include Validations::DayOfMonth   # n/a
+    include Validations::DayOfWeek
+    include Validations::Day
+    include Validations::MonthOfYear
+    # include Validations::DayOfYear    # n/a
+
     include Validations::WeeklyInterval
 
     attr_reader :week_start
@@ -28,7 +37,7 @@ def realign(step_time, start_time)
       time = TimeUtil::TimeWrapper.new(start_time)
       offset = wday_offset(step_time, start_time)
       time.add(:day, offset)
-      time.to_time
+      super step_time, time.to_time
     end
 
     # Calculate how many days to the first wday validation in the correct

lib/ice_cube/rules/yearly_rule.rb

@@ -2,6 +2,15 @@ module IceCube
 
   class YearlyRule < ValidatedRule
 
+    include Validations::HourOfDay
+    include Validations::MinuteOfHour
+    include Validations::SecondOfMinute
+    include Validations::DayOfMonth
+    include Validations::DayOfWeek
+    include Validations::Day
+    include Validations::MonthOfYear
+    include Validations::DayOfYear
+
     include Validations::YearlyInterval
 
     def initialize(interval = 1)

lib/ice_cube/time_util.rb

@@ -311,7 +311,17 @@ def clear_below(type)
         end
       end
 
-      private
+      def hour=(value)
+        @time += (value * ONE_HOUR) - (@time.hour * ONE_HOUR)
+      end
+
+      def min=(value)
+        @time += (value * ONE_MINUTE) - (@time.min * ONE_MINUTE)
+      end
+
+      def sec=(value)
+        @time += (value) - (@time.sec)
+      end
 
       def clear_sec
         @time.sec > 0 ? @time -= @time.sec : @time

lib/ice_cube/validated_rule.rb

@@ -1,18 +1,11 @@
+require 'ice_cube/input_alignment'
+
 module IceCube
 
   class ValidatedRule < Rule
 
     include Validations::ScheduleLock
 
-    include Validations::HourOfDay
-    include Validations::MinuteOfHour
-    include Validations::SecondOfMinute
-    include Validations::DayOfMonth
-    include Validations::DayOfWeek
-    include Validations::Day
-    include Validations::MonthOfYear
-    include Validations::DayOfYear
-
     include Validations::Count
     include Validations::Until
 
@@ -185,6 +178,12 @@ def validation_names
       VALIDATION_ORDER & @validations.keys
     end
 
+    def verify_alignment(value, freq, rule_part)
+      InputAlignment.new(self, value, rule_part).verify(freq) do |error|
+        yield error
+      end
+    end
+
   end
 
 end

lib/ice_cube/validations/daily_interval.rb

@@ -4,7 +4,11 @@ module Validations::DailyInterval
 
     # Add a new interval validation
     def interval(interval)
-      @interval = normalized_interval(interval)
+      interval = normalized_interval(interval)
+      verify_alignment(interval, :wday, :interval) { |error| raise error }
+      verify_alignment(interval, :day, :interval)  { |error| raise error }
+
+      @interval = interval
       replace_validations_for(:interval, [Validation.new(@interval)])
       clobber_base_validations(:wday, :day)
       self

lib/ice_cube/validations/day.rb

@@ -10,6 +10,8 @@ def day(*days)
           raise ArgumentError, "expecting Integer or Symbol value for day, got #{day.inspect}"
         end
         day = TimeUtil.sym_to_wday(day)
+        verify_alignment(day, :wday, :day) { |error| raise error }
+
         validations_for(:day) << Validation.new(day)
       end
       clobber_base_validations(:wday, :day)
@@ -25,6 +27,10 @@ def initialize(day)
         @day = day
       end
 
+      def key
+        :day
+      end
+
       def type
         :wday
       end

lib/ice_cube/validations/day_of_month.rb

@@ -7,6 +7,7 @@ def day_of_month(*days)
         unless day.is_a?(Integer)
           raise ArgumentError, "expecting Integer value for day, got #{day.inspect}"
         end
+        verify_alignment(day, :day, :day_of_month) { |error| raise error }
         validations_for(:day_of_month) << Validation.new(day)
       end
       clobber_base_validations(:day, :wday)
@@ -22,6 +23,10 @@ def initialize(day)
         @day = day
       end
 
+      def key
+        :day_of_month
+      end
+
       def type
         :day
       end

lib/ice_cube/validations/hour_of_day.rb

@@ -8,12 +8,31 @@ def hour_of_day(*hours)
         unless hour.is_a?(Integer)
           raise ArgumentError, "expecting Integer value for hour, got #{hour.inspect}"
         end
+
+        verify_alignment(hour, :hour, :hour_of_day) { |error| raise error }
+
         validations_for(:hour_of_day) << Validation.new(hour)
       end
       clobber_base_validations(:hour)
       self
     end
 
+    def realign(opening_time, start_time)
+      return super unless validations[:hour_of_day]
+      freq = base_interval_validation.interval
+
+      first_hour = Array(validations[:hour_of_day]).min_by(&:value)
+      time = TimeUtil::TimeWrapper.new(start_time, false)
+      if freq > 1
+        offset = first_hour.validate(opening_time, start_time)
+        time.add(:hour, offset - freq)
+      else
+        time.hour = first_hour.value
+      end
+
+      super opening_time, time.to_time
+    end
+
     class Validation < Validations::FixedValue
 
       attr_reader :hour
@@ -23,6 +42,10 @@ def initialize(hour)
         @hour = hour
       end
 
+      def key
+        :hour_of_day
+      end
+
       def type
         :hour
       end

lib/ice_cube/validations/hourly_interval.rb

@@ -3,6 +3,8 @@ module IceCube
   module Validations::HourlyInterval
 
     def interval(interval)
+      verify_alignment(interval, :hour, :interval) { |error| raise error }
+
       @interval = normalized_interval(interval)
       replace_validations_for(:interval, [Validation.new(@interval)])
       clobber_base_validations(:hour)