Refactor: extract class for verifying input

Move methods related to input verification into their own object.

Author: avit

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

@@ -20,26 +20,6 @@ def initialize(interval = 1)
       reset
     end
 
-    def verify_alignment(value, freq, rule_part)
-      return unless freq == :wday || freq == :day
-      return unless @validations[:interval]
-
-      interval_validation = @validations[:interval].first
-      interval_value = (rule_part == :interval) ? value : interval_validation.interval
-      return if interval_value == 1
-
-      if freq == :wday
-        return if (interval_value % 7).zero?
-        return if Array(@validations[:day]).empty?
-        message = "day can only be used with multiples of interval(7)"
-      else
-        (fixed_validation = other_fixed_value_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/monthly_rule.rb

@@ -20,19 +20,6 @@ def initialize(interval = 1)
       reset
     end
 
-    def verify_alignment(value, freq, rule_part)
-      return unless freq == :month
-      return unless @validations[:interval]
-
-      interval_validation = @validations[:interval].first
-      interval_value = (rule_part == :interval) ? value : interval_validation.interval
-      return if interval_value == 1 || (interval_value % 12).zero?
-      return if other_fixed_value_validations.empty?
-
-      message = "month_of_year can only be used with interval(1) or multiples of interval(12)"
-      yield ArgumentError.new(message)
-    end
-
   end
 
 end

lib/ice_cube/validated_rule.rb

@@ -1,3 +1,5 @@
+require 'ice_cube/input_alignment'
+
 module IceCube
 
   class ValidatedRule < Rule
@@ -42,14 +44,6 @@ def other_interval_validations
       Array(@validations[base_interval_validation.type])
     end
 
-    def other_fixed_value_validations
-      @validations.values.flatten.select { |v|
-        interval_type = (v.type == :wday ? :day : v.type)
-        v.class < Validations::FixedValue &&
-          interval_type == base_interval_validation.type
-      }
-    end
-
     # Compute the next time after (or including) the specified time in respect
     # to the given start time
     def next_time(time, start_time, closing_time)
@@ -184,27 +178,10 @@ def validation_names
       VALIDATION_ORDER & @validations.keys
     end
 
-    def verify_alignment(value, freq, rule_part, options={})
-      @validations[:interval] or return
-      interval_validation = @validations[:interval].first
-      interval_validation.type == freq or return
-      fixed_validations = other_fixed_value_validations
-      (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})"
+    def verify_alignment(value, freq, rule_part)
+      InputAlignment.new(self, value, rule_part).verify(freq) do |error|
+        yield error
       end
-      yield ArgumentError.new(message)
     end
 
   end