ice_cube 0.16.0 → 0.16.4

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,9 +384,22 @@ 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
+      [
+        TimeUtil.hash(start_time), duration,
+        *@all_recurrence_rules.map(&:hash).sort!,
+        *@all_exception_rules.map(&:hash).sort!
+      ].hash
+    end
+
+    def eql?(other)
+      self.hash == other.hash
+    end
+    alias == eql?
+
     def self.dump(schedule)
       return schedule if schedule.nil? || schedule == ""
       schedule.to_yaml
@@ -407,31 +421,24 @@ module IceCube
     # Find all of the occurrences for the schedule between opening_time
     # and closing_time
     # Iteration is unrolled in pairs to skip duplicate times in end of DST
-    def enumerate_occurrences(opening_time, closing_time = nil, options = {}, &block)
+    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|
         reset
-        t1 = full_required? ? start_time : opening_time - (spans ? duration : 0)
+        t1 = full_required? ? start_time : opening_time
+        t1 -= duration if spans
+        t1 = start_time if t1 < start_time
         loop do
           break unless (t0 = next_time(t1, closing_time))
           break if closing_time && t0 > closing_time
           if (spans ? (t0.end_time > opening_time) : (t0 >= opening_time))
-            yielder << (block_given? ? block.call(t0) : t0)
-          end
-          break unless (t1 = next_time(t0 + 1, closing_time))
-          break if closing_time && t1 > closing_time
-          if TimeUtil.same_clock?(t0, t1) && recurrence_rules.any?(&:dst_adjust?)
-            wind_back_dst
-            next (t1 += 1)
+            yielder << (block_given? ? yield(t0) : t0)
           end
-          if (spans ? (t1.end_time > opening_time) : (t1 >= opening_time))
-            yielder << (block_given? ? block.call(t1) : t1)
-          end
-          next (t1 += 1)
+          t1 = t0 + 1
         end
       end
     end
@@ -439,15 +446,15 @@ 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 nil unless min_time
+        break unless min_time
         next (time = min_time + 1) if exception_time?(min_time)
         break Occurrence.new(min_time, min_time + duration)
       end
@@ -498,12 +505,6 @@ module IceCube
       end
     end
 
-    def wind_back_dst
-      recurrence_rules.each do |rule|
-        rule.skipped_for_dst
-      end
-    end
-
   end
 
 end

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

@@ -47,7 +47,7 @@ module IceCube
                time.in_time_zone(reference.time_zone)
              else
                if reference.utc?
-                 time.utc
+                 time.getgm
                elsif reference.zone
                  time.getlocal
                else
@@ -89,18 +89,27 @@ module IceCube
 
     # Serialize a time appropriate for storing
     def self.serialize_time(time)
-      if time.respond_to?(:time_zone)
-        {:time => time.utc, :zone => time.time_zone.name}
-      elsif time.is_a?(Time)
-        time
+      case time
+      when Time, Date
+        if time.respond_to?(:time_zone)
+          {:time => time.utc, :zone => time.time_zone.name}
+        else
+          time
+        end
+      when DateTime
+        Time.local(time.year, time.month, time.day, time.hour, time.min, time.sec)
+      else
+        raise ArgumentError, "cannot serialize #{time.inspect}, expected a Time"
       end
     end
 
     # Deserialize a time serialized with serialize_time or in ISO8601 string format
     def self.deserialize_time(time_or_hash)
       case time_or_hash
-      when Time
+      when Time, Date
         time_or_hash
+      when DateTime
+        Time.local(time.year, time.month, time.day, time.hour, time.min, time.sec)
       when Hash
         hash = FlexibleHash.new(time_or_hash)
         hash[:time].in_time_zone(hash[:zone])
@@ -109,6 +118,14 @@ module IceCube
       end
     end
 
+    # Get a more precise equality for time objects
+    # Ruby provides a Time#hash method, but it fails to account for UTC
+    # offset (so the current date may be different) or DST rules (so the
+    # hour may be wrong for different schedule occurrences)
+    def self.hash(time)
+      [time, time.utc_offset, time.zone].hash
+    end
+
     # Check the deserialized time offset string against actual local time
     # offset to try and preserve the original offset for plain Ruby Time. If
     # the offset is the same as local we can assume the same original zone and
@@ -153,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
@@ -243,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
@@ -252,27 +273,32 @@ module IceCube
 
       def initialize(time, dst_adjust = true)
         @dst_adjust = dst_adjust
-        @time = time
+        @base = time
+        if dst_adjust
+          @time = Time.utc(time.year, time.month, time.day, time.hour, time.min, time.sec + TimeUtil.subsec(time))
+        else
+          @time = time
+        end
       end
 
-      # Get the wrapper time back
+      # Get the wrapped time back in its original zone & format
       def to_time
-        @time
+        return @time unless @dst_adjust
+        parts = @time.year, @time.month, @time.day, @time.hour, @time.min, @time.sec + @time.subsec
+        TimeUtil.build_in_zone(parts, @base)
       end
 
       # DST-safely add an interval of time to the wrapped time
       def add(type, val)
         type = :day if type == :wday
-        adjust do
-          @time += case type
-          when :year then TimeUtil.days_in_n_years(@time, val) * ONE_DAY
-          when :month then TimeUtil.days_in_n_months(@time, val) * ONE_DAY
-          when :day  then val * ONE_DAY
-          when :hour then val * ONE_HOUR
-          when :min  then val * ONE_MINUTE
-          when :sec  then val
-          end
-        end
+        @time += case type
+                 when :year then TimeUtil.days_in_n_years(@time, val) * ONE_DAY
+                 when :month then TimeUtil.days_in_n_months(@time, val) * ONE_DAY
+                 when :day  then val * ONE_DAY
+                 when :hour then val * ONE_HOUR
+                 when :min  then val * ONE_MINUTE
+                 when :sec  then val
+                 end
       end
 
       # Clear everything below a certain type
@@ -281,23 +307,20 @@ module IceCube
         type = :day if type == :wday
         CLEAR_ORDER.each do |ptype|
           break if ptype == type
-          adjust do
-            send(:"clear_#{ptype}")
-          end
+          send :"clear_#{ptype}"
         end
       end
 
-      private
+      def hour=(value)
+        @time += (value * ONE_HOUR) - (@time.hour * ONE_HOUR)
+      end
 
-      def adjust(&block)
-        if @dst_adjust
-          off = @time.utc_offset
-          yield
-          diff = off - @time.utc_offset
-          @time += diff if diff != 0
-        else
-          yield
-        end
+      def min=(value)
+        @time += (value * ONE_MINUTE) - (@time.min * ONE_MINUTE)
+      end
+
+      def sec=(value)
+        @time += (value) - (@time.sec)
       end
 
       def clear_sec
@@ -326,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,15 +44,14 @@ 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)
       @time = time
-      @start_time ||= realign(time, start_time)
+      unless @start_time
+        @start_time = realign(time, start_time)
+        @time = @start_time if @time < @start_time
+      end
 
       return nil unless find_acceptable_time_before(closing_time)
 
@@ -71,17 +63,13 @@ 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
       builder = StringBuilder.new
-      @validations.each do |name, validations|
+      @validations.each_value do |validations|
         validations.each do |validation|
           validation.build_s(builder)
         end
@@ -91,7 +79,7 @@ module IceCube
 
     def to_hash
       builder = HashBuilder.new(self)
-      @validations.each do |name, validations|
+      @validations.each_value do |validations|
         validations.each do |validation|
           validation.build_hash(builder)
         end
@@ -101,7 +89,7 @@ module IceCube
 
     def to_ical
       builder = IcalBuilder.new
-      @validations.each do |name, validations|
+      @validations.each_value do |validations|
         validations.each do |validation|
           validation.build_ical(builder)
         end
@@ -134,7 +122,7 @@ module IceCube
 
     def normalized_interval(interval)
       int = interval.to_i
-      raise ArgumentError, "'#{interval}' is not a valid input for interval. Please pass an integer." unless int > 0
+      raise ArgumentError, "'#{interval}' is not a valid input for interval. Please pass a postive integer." unless int > 0
       int
     end
 
@@ -190,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/day_of_week.rb

@@ -48,7 +48,7 @@ module IceCube
         builder.piece(:day_of_week) << IceCube::I18n.t(
           'ice_cube.days_of_week',
           segments: StringBuilder.nice_number(occ),
-          day: IceCube::I18n.t('ice_cube.date.day_names')[day]
+          day: IceCube::I18n.t('date.day_names')[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
@@ -32,7 +37,7 @@ module IceCube
       end
 
       def build_s(builder)
-        builder.piece(:month_of_year) << IceCube::I18n.t("ice_cube.date.month_names")[month]
+        builder.piece(:month_of_year) << IceCube::I18n.t("date.month_names")[month]
       end
 
       def build_hash(builder)

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