ice_cube 0.15.0 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4da7e2dd818b7ab5f3c5dd023370bbc80f8e8ced
-  data.tar.gz: e131a536a09b9c2bda6373b8c1f76cc2b8857245
+  metadata.gz: 01f55d89af28400fc30bdfe60ccacd66e42212b0
+  data.tar.gz: a7e85b8afe0d56f8b47c3e22139d080e035ee465
 SHA512:
-  metadata.gz: 0ea3d24d220d7683a46c74b7b63bb2ab9959de7e1b4d08dd96664593f99bf78402e0f27fc395a4e21e46ce7cdea01a7780b7c5948fc10299a671cfe8f1c4a8f9
-  data.tar.gz: ab2b07d2a5023c56a165b0cd3f8407f4c36816413efb005e1e31a8b82123cd4ba878a710b05832c2d521804d6dfb62fbd328199286b32e341e64f0e180fdd7ea
+  metadata.gz: a87067a8e0a099b1f9740bd4dab4ed408c72827c1498370b81ba3df3f6246fc7be12f8343f63832554dfa990f1754e5af365755831490d767df84b3462d49a41
+  data.tar.gz: d41ba1b2a5dc98db1522a38320452d9404a92510872a0473ba6dc9b440a5258352ea484ce28dc663908bf6bc19d747f4099035549865745377e4be9f035aed28

data/lib/ice_cube/deprecated.rb

@@ -7,7 +7,7 @@ module IceCube
     def deprecated_alias(name, replacement)
       # Create a wrapped version
       define_method(name) do |*args, &block|
-        warn "IceCube: #{self.class}##{name} is deprecated, please use ##{replacement} at: #{ caller[0] }"
+        warn "IceCube: #{self.class}##{name} is deprecated (use #{replacement})", caller[0]
         send replacement, *args, &block
       end
     end
@@ -21,14 +21,15 @@ module IceCube
       alias_method old_name, name
       # And replace it with a wrapped version
       define_method(name) do |*args, &block|
-        warn "IceCube: #{self.class}##{name} is deprecated, please use ##{replacement} at: #{ caller[0] }"
+        warn "IceCube: #{self.class}##{name} is deprecated (use #{replacement})", caller[0]
         send old_name, *args, &block
       end
     end
 
     def self.schedule_options(schedule, options)
       if options[:start_date_override]
-        warn "IceCube: :start_date_override option is deprecated, please use a block {|s| s.start_time = override }. at: #{ caller[0] }"
+        warn "IceCube: :start_date_override option is deprecated " \
+             "(use a block: `{|s| s.start_time = override }`)", caller[0]
         schedule.start_time = options[:start_date_override]
       end
     end

data/lib/ice_cube/parsers/ical_parser.rb

@@ -31,6 +31,7 @@ module IceCube
 
       ical.split(';').each do |rule|
         (name, value) = rule.split('=')
+        raise ArgumentError, "Invalid iCal rule component" if value.nil?
         value.strip!
         case name
         when 'FREQ'

data/lib/ice_cube/rule.rb

@@ -11,6 +11,9 @@ module IceCube
 
     attr_reader :uses
 
+    def reset
+    end
+
     # Is this a terminating schedule?
     def terminating?
       until_time || occurrence_count
@@ -51,11 +54,6 @@ module IceCube
       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
 
@@ -73,18 +71,30 @@ module IceCube
       # Convert from a hash and create a rule
       def from_hash(original_hash)
         hash = IceCube::FlexibleHash.new original_hash
-        return nil unless match = hash[:rule_type].match(/\:\:(.+?)Rule/)
+
+        unless hash[:rule_type] && match = hash[:rule_type].match(/\:\:(.+?)Rule/)
+          raise ArgumentError, 'Invalid rule type'
+        end
 
         interval_type = match[1].downcase.to_sym
-        raise ArgumentError, "Invalid rule frequency type: #{match[1]}" unless INTERVAL_TYPES.include?(interval_type)
+
+        unless INTERVAL_TYPES.include?(interval_type)
+          raise ArgumentError, "Invalid rule frequency type: #{match[1]}"
+        end
 
         rule = IceCube::Rule.send(interval_type, hash[:interval] || 1)
-        rule.interval(hash[:interval] || 1, TimeUtil.wday_to_sym(hash[:week_start] || 0)) if match[1] == "Weekly"
+
+        if match[1] == "Weekly"
+          rule.interval(hash[:interval] || 1, TimeUtil.wday_to_sym(hash[:week_start] || 0))
+        end
+
         rule.until(TimeUtil.deserialize_time(hash[:until])) if hash[:until]
         rule.count(hash[:count]) if hash[:count]
+
         hash[:validations] && hash[:validations].each do |name, args|
           apply_validation(rule, name, args)
         end
+
         rule
       end
 
@@ -92,7 +102,11 @@ module IceCube
 
       def apply_validation(rule, name, args)
         name = name.to_sym
-        raise ArgumentError, "Invalid rule validation type: #{name}" unless ValidatedRule::VALIDATION_ORDER.include?(name)
+
+        unless ValidatedRule::VALIDATION_ORDER.include?(name)
+          raise ArgumentError, "Invalid rule validation type: #{name}"
+        end
+
         args.is_a?(Array) ? rule.send(name, *args) : rule.send(name, args)
       end
 

data/lib/ice_cube/rules/daily_rule.rb

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

data/lib/ice_cube/rules/hourly_rule.rb

@@ -4,7 +4,7 @@ module IceCube
 
     include Validations::HourlyInterval
 
-    def initialize(interval = 1, week_start = :sunday)
+    def initialize(interval = 1)
       super
       interval(interval)
       schedule_lock(:min, :sec)

data/lib/ice_cube/rules/minutely_rule.rb

@@ -4,7 +4,7 @@ module IceCube
 
     include Validations::MinutelyInterval
 
-    def initialize(interval = 1, week_start = :sunday)
+    def initialize(interval = 1)
       super
       interval(interval)
       schedule_lock(:sec)

data/lib/ice_cube/rules/monthly_rule.rb

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

data/lib/ice_cube/rules/secondly_rule.rb

@@ -4,7 +4,7 @@ module IceCube
 
     include Validations::SecondlyInterval
 
-    def initialize(interval = 1, week_start = :sunday)
+    def initialize(interval = 1)
       super
       interval(interval)
       reset

data/lib/ice_cube/rules/weekly_rule.rb

@@ -4,13 +4,39 @@ module IceCube
 
     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

data/lib/ice_cube/rules/yearly_rule.rb

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

data/lib/ice_cube/schedule.rb

@@ -46,7 +46,7 @@ module IceCube
 
     # Add a recurrence time to the schedule
     def add_recurrence_time(time)
-      return nil if time.nil?
+      return if time.nil?
       rule = SingleOccurrenceRule.new(time)
       add_recurrence_rule rule
       time
@@ -57,7 +57,7 @@ module IceCube
 
     # Add an exception time to the schedule
     def add_exception_time(time)
-      return nil if time.nil?
+      return if time.nil?
       rule = SingleOccurrenceRule.new(time)
       add_exception_rule rule
       time
@@ -68,6 +68,7 @@ module IceCube
 
     # Add a recurrence rule to the schedule
     def add_recurrence_rule(rule)
+      return if rule.nil?
       @all_recurrence_rules << rule unless @all_recurrence_rules.include?(rule)
     end
     alias :rrule :add_recurrence_rule
@@ -80,6 +81,7 @@ module IceCube
 
     # Add an exception rule to the schedule
     def add_exception_rule(rule)
+      return if rule.nil?
       @all_exception_rules << rule unless @all_exception_rules.include?(rule)
     end
     alias :exrule :add_exception_rule
@@ -413,7 +415,7 @@ module IceCube
       spans = options[:spans] == true && duration != 0
       Enumerator.new do |yielder|
         reset
-        t1 = full_required? ? start_time : realign((spans ? opening_time - duration : opening_time))
+        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 +441,7 @@ module IceCube
       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 +464,7 @@ module IceCube
     # 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 +504,6 @@ module IceCube
       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

data/lib/ice_cube/single_occurrence_rule.rb

@@ -13,7 +13,7 @@ module IceCube
       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

data/lib/ice_cube/time_util.rb

@@ -135,7 +135,7 @@ module IceCube
     def self.sym_to_month(sym)
       MONTHS.fetch(sym) do |k|
         MONTHS.values.detect { |i| i.to_s == k.to_s } or
-        raise ArgumentError, "Expecting Fixnum or Symbol value for month. " \
+        raise ArgumentError, "Expecting Integer or Symbol value for month. " \
                              "No such month: #{k.inspect}"
       end
     end
@@ -145,7 +145,7 @@ module IceCube
     def self.sym_to_wday(sym)
       DAYS.fetch(sym) do |k|
         DAYS.values.detect { |i| i.to_s == k.to_s } or
-        raise ArgumentError, "Expecting Fixnum or Symbol value for weekday. " \
+        raise ArgumentError, "Expecting Integer or Symbol value for weekday. " \
                              "No such weekday: #{k.inspect}"
       end
     end
@@ -155,7 +155,7 @@ module IceCube
     def self.wday_to_sym(wday)
       return sym = wday if DAYS.keys.include? wday
       DAYS.invert.fetch(wday) do |i|
-        raise ArgumentError, "Expecting Fixnum value for weekday. " \
+        raise ArgumentError, "Expecting Integer value for weekday. " \
                              "No such wday number: #{i.inspect}"
       end
     end

data/lib/ice_cube/validated_rule.rb

@@ -32,10 +32,17 @@ module IceCube
 
     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,10 +56,10 @@ module IceCube
     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)
 
@@ -60,6 +67,10 @@ module IceCube
       @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 @@ module IceCube
     #
     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

data/lib/ice_cube/validations/count.rb

@@ -8,8 +8,8 @@ module IceCube
     end
 
     def count(max)
-      unless max.nil? || max.is_a?(Fixnum)
-        raise ArgumentError, "Expecting Fixnum or nil value for count, got #{max.inspect}"
+      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)])
@@ -33,7 +33,7 @@ module IceCube
         false
       end
 
-      def validate(time, schedule)
+      def validate(time, start_time)
         raise CountExceeded if rule.uses && rule.uses >= count
       end
 

data/lib/ice_cube/validations/daily_interval.rb

@@ -26,8 +26,8 @@ module IceCube
         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?

data/lib/ice_cube/validations/day.rb

@@ -8,8 +8,8 @@ module IceCube
       days = days.flatten
       return self if days.empty?
       days.flatten.each do |day|
-        unless day.is_a?(Fixnum) || day.is_a?(Symbol)
-          raise ArgumentError, "expecting Fixnum or Symbol value for day, got #{day.inspect}"
+        unless day.is_a?(Integer) || day.is_a?(Symbol)
+          raise ArgumentError, "expecting Integer or Symbol value for day, got #{day.inspect}"
         end
         day = TimeUtil.sym_to_wday(day)
         validations_for(:day) << Validation.new(day)

data/lib/ice_cube/validations/day_of_month.rb

@@ -4,8 +4,8 @@ module IceCube
 
     def day_of_month(*days)
       days.flatten.each do |day|
-        unless day.is_a?(Fixnum)
-          raise ArgumentError, "expecting Fixnum value for day, got #{day.inspect}"
+        unless day.is_a?(Integer)
+          raise ArgumentError, "expecting Integer value for day, got #{day.inspect}"
         end
         validations_for(:day_of_month) << Validation.new(day)
       end

data/lib/ice_cube/validations/day_of_week.rb

@@ -30,7 +30,7 @@ module IceCube
         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)

data/lib/ice_cube/validations/day_of_year.rb

@@ -4,8 +4,8 @@ module IceCube
 
     def day_of_year(*days)
       days.flatten.each do |day|
-        unless day.is_a?(Fixnum)
-          raise ArgumentError, "expecting Fixnum value for day, got #{day.inspect}"
+        unless day.is_a?(Integer)
+          raise ArgumentError, "expecting Integer value for day, got #{day.inspect}"
         end
         validations_for(:day_of_year) << Validation.new(day)
       end
@@ -29,9 +29,9 @@ module IceCube
         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 : day
+        yday = day < 0 ? day + days_in_year + 1 : day
         offset = yday - step_time.yday
         offset >= 0 ? offset : offset + days_in_year
       end

data/lib/ice_cube/validations/fixed_value.rb

@@ -12,11 +12,11 @@ module IceCube
 
     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,8 +25,8 @@ module IceCube
     # 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
@@ -34,8 +34,8 @@ module IceCube
     # 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 @@ module IceCube
     # 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 @@ module IceCube
         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
 

data/lib/ice_cube/validations/hour_of_day.rb

@@ -5,8 +5,8 @@ module IceCube
     # Add hour of day validations
     def hour_of_day(*hours)
       hours.flatten.each do |hour|
-        unless hour.is_a?(Fixnum)
-          raise ArgumentError, "expecting Fixnum value for hour, got #{hour.inspect}"
+        unless hour.is_a?(Integer)
+          raise ArgumentError, "expecting Integer value for hour, got #{hour.inspect}"
         end
         validations_for(:hour_of_day) << Validation.new(hour)
       end

data/lib/ice_cube/validations/hourly_interval.rb

@@ -25,8 +25,8 @@ module IceCube
         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

data/lib/ice_cube/validations/lock.rb

@@ -12,11 +12,11 @@ module IceCube
 
     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,8 +25,8 @@ module IceCube
     # 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
@@ -34,8 +34,8 @@ module IceCube
     # 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 @@ module IceCube
     # 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 @@ module IceCube
         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
 

data/lib/ice_cube/validations/minute_of_hour.rb

@@ -4,8 +4,8 @@ module IceCube
 
     def minute_of_hour(*minutes)
       minutes.flatten.each do |minute|
-        unless minute.is_a?(Fixnum)
-          raise ArgumentError, "expecting Fixnum value for minute, got #{minute.inspect}"
+        unless minute.is_a?(Integer)
+          raise ArgumentError, "expecting Integer value for minute, got #{minute.inspect}"
         end
         validations_for(:minute_of_hour) << Validation.new(minute)
       end

data/lib/ice_cube/validations/minutely_interval.rb

@@ -25,8 +25,8 @@ module IceCube
         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_MINUTE) -
               (t0 - t0 % ONE_MINUTE)
         minutes = sec / ONE_MINUTE

data/lib/ice_cube/validations/month_of_year.rb

@@ -4,8 +4,8 @@ module IceCube
 
     def month_of_year(*months)
       months.flatten.each do |month|
-        unless month.is_a?(Fixnum) || month.is_a?(Symbol)
-          raise ArgumentError, "expecting Fixnum or Symbol value for month, got #{month.inspect}"
+        unless month.is_a?(Integer) || month.is_a?(Symbol)
+          raise ArgumentError, "expecting Integer or Symbol value for month, got #{month.inspect}"
         end
         month = TimeUtil.sym_to_month(month)
         validations_for(:month_of_year) << Validation.new(month)

data/lib/ice_cube/validations/monthly_interval.rb

@@ -25,8 +25,8 @@ module IceCube
         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
         months = (t1.month - t0.month) +
                  (t1.year - t0.year) * 12
         offset = (months % interval).nonzero?

data/lib/ice_cube/validations/second_of_minute.rb

@@ -4,8 +4,8 @@ module IceCube
 
     def second_of_minute(*seconds)
       seconds.flatten.each do |second|
-      unless second.is_a?(Fixnum)
-        raise ArgumentError, "Expecting Fixnum value for second, got #{second.inspect}"
+      unless second.is_a?(Integer)
+        raise ArgumentError, "Expecting Integer value for second, got #{second.inspect}"
       end
         validations_for(:second_of_minute) << Validation.new(second)
       end

data/lib/ice_cube/validations/secondly_interval.rb

@@ -25,8 +25,8 @@ module IceCube
         false
       end
 
-      def validate(step_time, schedule)
-        seconds = step_time.to_i - schedule.start_time.to_i
+      def validate(step_time, start_time)
+        seconds = step_time.to_i - start_time.to_i
         offset = (seconds % interval).nonzero?
         interval - offset if offset
       end

data/lib/ice_cube/validations/until.rb

@@ -32,8 +32,8 @@ module IceCube
         false
       end
 
-      def validate(step_time, schedule)
-        end_time = TimeUtil.ensure_time(time, schedule.start_time, true)
+      def validate(step_time, start_time)
+        end_time = TimeUtil.ensure_time(time, start_time, true)
         raise UntilExceeded if step_time > end_time
       end
 

data/lib/ice_cube/validations/weekly_interval.rb

@@ -12,10 +12,6 @@ module IceCube
       self
     end
 
-    def week_start
-      @week_start
-    end
-
     class Validation
 
       attr_reader :interval, :week_start
@@ -33,8 +29,9 @@ module IceCube
         true
       end
 
-      def validate(step_time, schedule)
-        t0, t1 = schedule.start_time, step_time
+      def validate(step_time, start_time)
+        return if step_time < start_time
+        t0, t1 = start_time, step_time
         d0 = Date.new(t0.year, t0.month, t0.day)
         d1 = Date.new(t1.year, t1.month, t1.day)
         days = (d1 - TimeUtil.normalize_wday(d1.wday, week_start)) -

data/lib/ice_cube/validations/yearly_interval.rb

@@ -25,8 +25,8 @@ module IceCube
         true
       end
 
-      def validate(step_time, schedule)
-        years = step_time.year - schedule.start_time.year
+      def validate(step_time, start_time)
+        years = step_time.year - start_time.year
         offset = (years % interval).nonzero?
         interval - offset if offset
       end

data/lib/ice_cube/version.rb

@@ -1,5 +1,5 @@
 module IceCube
 
-  VERSION = '0.15.0'
+  VERSION = '0.16.0'
 
 end

data/spec/spec_helper.rb

@@ -1,3 +1,6 @@
+require "bundler/setup"
+require 'ice_cube'
+
 begin
   require 'simplecov'
   SimpleCov.start
@@ -5,8 +8,6 @@ rescue LoadError
   # okay
 end
 
-require File.dirname(__FILE__) + '/../lib/ice_cube'
-
 IceCube.compatibility = 12
 
 DAY = Time.utc(2010, 3, 1)
@@ -19,46 +20,37 @@ WORLD_TIME_ZONES = [
 ]
 
 RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
   Dir[File.dirname(__FILE__) + '/support/**/*'].each { |f| require f }
 
   config.include WarningHelpers
 
-  config.around :each, :if_active_support_time => true do |example|
-    example.run if defined? ActiveSupport
-  end
-
-  config.around :each, :if_active_support_time => false do |example|
-    unless defined? ActiveSupport
-      stubbed_active_support = ::ActiveSupport = Module.new
-      example.run
-      Object.send :remove_const, :ActiveSupport
+  config.before :each do |example|
+    if example.metadata[:requires_active_support]
+      raise 'ActiveSupport required but not present' unless defined?(ActiveSupport)
     end
   end
 
   config.around :each do |example|
     if zone = example.metadata[:system_time_zone]
-      @orig_zone = ENV['TZ']
+      orig_zone = ENV['TZ']
       ENV['TZ'] = zone
       example.run
-      ENV['TZ'] = @orig_zone
+      ENV['TZ'] = orig_zone
     else
       example.run
     end
   end
 
-  config.before :each do
-    if time_args = @example.metadata[:system_time]
-      case time_args
-      when Array then Time.stub!(:now).and_return Time.local(*time_args)
-      when Time  then Time.stub!(:now).and_return time_args
-      end
-    end
-  end
-
   config.around :each, expect_warnings: true do |example|
     capture_warnings do
       example.run
     end
   end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ice_cube
 version: !ruby/object:Gem::Version
-  version: 0.15.0
+  version: 0.16.0
 platform: ruby
 authors:
 - John Crepezzi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-28 00:00:00.000000000 Z
+date: 2017-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -28,16 +28,16 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
-        version: 2.12.0
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">"
       - !ruby/object:Gem::Version
-        version: 2.12.0
+        version: '3'
 description: ice_cube is a recurring date library for Ruby.  It allows for quick,
   programatic expansion of recurring date rules.
 email: john@crepezzi.com