ice_cube 0.16.2 → 0.16.4

data/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)

data/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)

data/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)

data/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 @@ module IceCube
       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

data/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)

data/lib/ice_cube/schedule.rb

@@ -340,9 +340,9 @@ module IceCube
       IcalParser.schedule_from_ical(ical, options)
     end
 
-    # Convert the schedule to yaml
-    def to_yaml(*args)
-      YAML::dump(to_hash, *args)
+    # Hook for YAML.dump, enables to_yaml
+    def encode_with(coder)
+      coder.represent_object nil, to_hash
     end
 
     # Load the schedule from yaml
@@ -371,6 +371,7 @@ module IceCube
       end
       data
     end
+    alias_method :to_h, :to_hash
 
     # Load the schedule from a hash
     def self.from_hash(original_hash, options = {})
@@ -383,7 +384,7 @@ module IceCube
     # Determine if the schedule will end
     # @return [Boolean] true if ending, false if repeating forever
     def terminating?
-      recurrence_rules.empty? || recurrence_rules.all?(&:terminating?)
+      @all_recurrence_rules.all?(&:terminating?)
     end
 
     def hash
@@ -423,7 +424,7 @@ module IceCube
     def enumerate_occurrences(opening_time, closing_time = nil, options = {})
       opening_time = TimeUtil.match_zone(opening_time, start_time)
       closing_time = TimeUtil.match_zone(closing_time, start_time)
-      opening_time += start_time.subsec - opening_time.subsec rescue 0
+      opening_time += TimeUtil.subsec(start_time) - TimeUtil.subsec(opening_time)
       opening_time = start_time if opening_time < start_time
       spans = options[:spans] == true && duration != 0
       Enumerator.new do |yielder|
@@ -445,12 +446,12 @@ module IceCube
     # Get the next time after (or including) a specific time
     def next_time(time, closing_time)
       loop do
-        min_time = recurrence_rules_with_implicit_start_occurrence.reduce(nil) do |min_time, rule|
+        min_time = recurrence_rules_with_implicit_start_occurrence.reduce(nil) do |best_time, rule|
           begin
-            new_time = rule.next_time(time, start_time, min_time || closing_time)
-            [min_time, new_time].compact.min
+            new_time = rule.next_time(time, start_time, best_time || closing_time)
+            [best_time, new_time].compact.min
           rescue StopIteration
-            min_time
+            best_time
           end
         end
         break unless min_time

data/lib/ice_cube/single_occurrence_rule.rb

@@ -23,6 +23,10 @@ module IceCube
       { :time => time }
     end
 
+    def full_required?
+      false
+    end
+
   end
 
 end

data/lib/ice_cube/time_util.rb

@@ -170,20 +170,13 @@ module IceCube
 
     # Convert wday number to day symbol
     def self.wday_to_sym(wday)
-      return sym = wday if DAYS.keys.include? wday
+      return wday if DAYS.keys.include? wday
       DAYS.invert.fetch(wday) do |i|
         raise ArgumentError, "Expecting Integer value for weekday. " \
                              "No such wday number: #{i.inspect}"
       end
     end
 
-    # Convert a symbol to an ical day (SU, MO)
-    def self.week_start(sym)
-      raise ArgumentError, "Invalid day: #{str}" unless DAYS.keys.include?(sym)
-      day = sym.to_s.upcase[0..1]
-      day
-    end
-
     # Convert weekday from base sunday to the schedule's week start.
     def self.normalize_wday(wday, week_start)
       (wday - sym_to_wday(week_start)) % 7
@@ -260,8 +253,19 @@ module IceCube
       end
     end
 
-    def self.same_clock?(t1, t2)
-      CLOCK_VALUES.all? { |i| t1.send(i) == t2.send(i) }
+    # Handle discrepancies between various time types
+    # - Time has subsec
+    # - DateTime does not
+    # - ActiveSupport::TimeWithZone can wrap either type, depending on version
+    #   or if `parse` or `now`/`local` was used to build it.
+    def self.subsec(time)
+      if time.respond_to?(:subsec)
+        time.subsec
+      elsif time.respond_to?(:sec_fraction)
+        time.sec_fraction
+      else
+        0.0
+      end
     end
 
     # A utility class for safely moving time around
@@ -271,7 +275,7 @@ module IceCube
         @dst_adjust = dst_adjust
         @base = time
         if dst_adjust
-          @time = Time.utc(time.year, time.month, time.day, time.hour, time.min, time.sec + time.subsec)
+          @time = Time.utc(time.year, time.month, time.day, time.hour, time.min, time.sec + TimeUtil.subsec(time))
         else
           @time = time
         end
@@ -307,7 +311,17 @@ module IceCube
         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
@@ -335,10 +349,6 @@ module IceCube
         @time += ONE_DAY
       end
 
-      def clear_year
-        @time
-      end
-
     end
 
   end

data/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
 
@@ -51,10 +44,6 @@ module IceCube
       Array(@validations[base_interval_validation.type])
     end
 
-    def base_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)
@@ -74,12 +63,8 @@ module IceCube
       start_time
     end
 
-    def skipped_for_dst
-      @uses -= 1 if @uses > 0
-    end
-
-    def dst_adjust?
-      @validations[:interval].any?(&:dst_adjust?)
+    def full_required?
+      !occurrence_count.nil?
     end
 
     def to_s
@@ -193,6 +178,12 @@ module IceCube
       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

data/lib/ice_cube/validations/count.rb

@@ -4,14 +4,13 @@ module IceCube
 
     # Value reader for limit
     def occurrence_count
-      @count
+      (arr = @validations[:count]) && (val = arr[0]) && val.count
     end
 
     def count(max)
       unless max.nil? || max.is_a?(Integer)
         raise ArgumentError, "Expecting Integer or nil value for count, got #{max.inspect}"
       end
-      @count = max
       replace_validations_for(:count, max && [Validation.new(max, self)])
       self
     end

data/lib/ice_cube/validations/daily_interval.rb

@@ -4,7 +4,11 @@ module IceCube
 
     # 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

data/lib/ice_cube/validations/day.rb

@@ -1,5 +1,3 @@
-require 'date'
-
 module IceCube
 
   module Validations::Day
@@ -12,6 +10,8 @@ module IceCube
           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)
@@ -27,6 +27,10 @@ module IceCube
         @day = day
       end
 
+      def key
+        :day
+      end
+
       def type
         :wday
       end

data/lib/ice_cube/validations/day_of_month.rb

@@ -7,6 +7,7 @@ module IceCube
         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 @@ module IceCube
         @day = day
       end
 
+      def key
+        :day_of_month
+      end
+
       def type
         :day
       end

data/lib/ice_cube/validations/hour_of_day.rb

@@ -8,12 +8,31 @@ module IceCube
         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 && base_interval_validation.type == :hour
+        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 @@ module IceCube
         @hour = hour
       end
 
+      def key
+        :hour_of_day
+      end
+
       def type
         :hour
       end

data/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)

data/lib/ice_cube/validations/minute_of_hour.rb

@@ -7,12 +7,24 @@ module IceCube
         unless minute.is_a?(Integer)
           raise ArgumentError, "expecting Integer value for minute, got #{minute.inspect}"
         end
+
+        verify_alignment(minute, :min, :minute_of_hour) { |error| raise error }
+
         validations_for(:minute_of_hour) << Validation.new(minute)
       end
       clobber_base_validations(:min)
       self
     end
 
+    def realign(opening_time, start_time)
+      return super unless validations[:minute_of_hour]
+
+      first_minute = validations[:minute_of_hour].min_by(&:value)
+      time = TimeUtil::TimeWrapper.new(start_time, false)
+      time.min = first_minute.value
+      super opening_time, time.to_time
+    end
+
     class Validation < Validations::FixedValue
 
       attr_reader :minute
@@ -22,6 +34,10 @@ module IceCube
         @minute = minute
       end
 
+      def key
+        :minute_of_hour
+      end
+
       def type
         :min
       end

data/lib/ice_cube/validations/minutely_interval.rb

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

data/lib/ice_cube/validations/month_of_year.rb

@@ -8,6 +8,7 @@ module IceCube
           raise ArgumentError, "expecting Integer or Symbol value for month, got #{month.inspect}"
         end
         month = TimeUtil.sym_to_month(month)
+        verify_alignment(month, :month, :month_of_year) { |error| raise error }
         validations_for(:month_of_year) << Validation.new(month)
       end
       clobber_base_validations :month
@@ -23,6 +24,10 @@ module IceCube
         @month = month
       end
 
+      def key
+        :month_of_year
+      end
+
       def type
         :month
       end

data/lib/ice_cube/validations/monthly_interval.rb

@@ -3,7 +3,10 @@ module IceCube
   module Validations::MonthlyInterval
 
     def interval(interval)
-      @interval = normalized_interval(interval)
+      interval = normalized_interval(interval)
+      verify_alignment(interval, :month, :interval) { |error| raise error }
+
+      @interval = interval
       replace_validations_for(:interval, [Validation.new(@interval)])
       clobber_base_validations(:month)
       self

data/lib/ice_cube/validations/schedule_lock.rb

@@ -20,6 +20,10 @@ module IceCube
         @type = type
       end
 
+      def key
+        :base
+      end
+
       def dst_adjust?
         case @type
         when :sec, :min then false

data/lib/ice_cube/validations/second_of_minute.rb

@@ -4,15 +4,27 @@ module IceCube
 
     def second_of_minute(*seconds)
       seconds.flatten.each do |second|
-      unless second.is_a?(Integer)
-        raise ArgumentError, "Expecting Integer value for second, got #{second.inspect}"
-      end
+        unless second.is_a?(Integer)
+          raise ArgumentError, "Expecting Integer value for second, got #{second.inspect}"
+        end
+
+        verify_alignment(second, :sec, :second_of_minute) { |error| raise error }
+
         validations_for(:second_of_minute) << Validation.new(second)
       end
       clobber_base_validations :sec
       self
     end
 
+    def realign(opening_time, start_time)
+      return super unless validations[:second_of_minute]
+
+      first_second = Array(validations[:second_of_minute]).min_by(&:value)
+      time = TimeUtil::TimeWrapper.new(start_time, false)
+      time.sec = first_second.value
+      super opening_time, time.to_time
+    end
+
     class Validation < Validations::FixedValue
 
       attr_reader :second
@@ -22,6 +34,10 @@ module IceCube
         @second = second
       end
 
+      def key
+        :second_of_minute
+      end
+
       def type
         :sec
       end

data/lib/ice_cube/validations/secondly_interval.rb

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

data/lib/ice_cube/validations/until.rb

@@ -6,12 +6,11 @@ module IceCube
 
     # Value reader for limit
     def until_time
-      @until
+      (arr = @validations[:until]) && (val = arr[0]) && val.time
     end
     deprecated_alias :until_date, :until_time
 
     def until(time)
-      @until = time
       replace_validations_for(:until, time.nil? ? nil : [Validation.new(time)])
       self
     end

data/lib/ice_cube/validations/weekly_interval.rb

@@ -1,5 +1,3 @@
-require 'date'
-
 module IceCube
 
   module Validations::WeeklyInterval

data/lib/ice_cube/version.rb

@@ -1,5 +1,5 @@
 module IceCube
 
-  VERSION = '0.16.2'
+  VERSION = '0.16.4'
 
 end

data/lib/ice_cube.rb

@@ -1,8 +1,5 @@
 require 'date'
 require 'ice_cube/deprecated'
-require 'ice_cube/i18n'
-
-IceCube::I18n.detect_backend!
 
 module IceCube
 
@@ -10,6 +7,7 @@ module IceCube
 
   autoload :TimeUtil, 'ice_cube/time_util'
   autoload :FlexibleHash, 'ice_cube/flexible_hash'
+  autoload :I18n, 'ice_cube/i18n'
 
   autoload :Rule, 'ice_cube/rule'
   autoload :Schedule, 'ice_cube/schedule'