ice_cube 0.9.3 → 0.10.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0cc5c669bd801317d8256d7fc8b77841e80dae6e
+  data.tar.gz: 6bda80589b1d0a91d54ea2d7b4194d320e26b2ac
+SHA512:
+  metadata.gz: d3a10207a9dc7368b3cc6f045160c2b3f6651e1a95570a8d6c58af689eb616deb47291485b514b4ec58b1275595dce7f7c21f1606341d624449edfc5c842648d
+  data.tar.gz: 0abec738ddd565630a8a92468a8db708c2c18e2601abe3824ba10b766ce952341d7ff90da50a7ac6f4349d079661d66e8b131f177cbf4ee2853b4b046d4389a6

data/lib/ice_cube.rb

@@ -17,6 +17,7 @@ module IceCube
 
   autoload :Rule, 'ice_cube/rule'
   autoload :Schedule, 'ice_cube/schedule'
+  autoload :Occurrence, 'ice_cube/occurrence'
 
   autoload :IcalBuilder, 'ice_cube/builders/ical_builder'
   autoload :HashBuilder, 'ice_cube/builders/hash_builder'

data/lib/ice_cube/occurrence.rb

@@ -0,0 +1,90 @@
+require 'forwardable'
+require 'delegate'
+
+module IceCube
+
+  # Wraps start_time and end_time in a single concept concerning the duration.
+  # This delegates to the enclosed start_time so it behaves like a normal Time
+  # in almost all situations, however:
+  #
+  # Without ActiveSupport, it's necessary to cast the occurrence using
+  # +#to_time+ before doing arithmetic, else Time will try to subtract it
+  # using +#to_i+ and return a new time instead.
+  #
+  #     Time.now - Occurrence.new(start_time) # => 1970-01-01 01:00:00
+  #     Time.now - Occurrence.new(start_time).to_time # => 3600
+  #
+  # When ActiveSupport::Time core extensions are loaded, it's possible to
+  # subtract an Occurrence object directly from a Time to get the difference:
+  #
+  #     Time.now - Occurrence.new(start_time) # => 3600
+  #
+  class Occurrence < SimpleDelegator
+
+    # Optimize for common methods to avoid method_missing
+    extend Forwardable
+    def_delegators :start_time, :to_s, :to_i, :<=>, :==
+    def_delegators :to_range, :cover?, :include?, :each, :first, :last
+
+    attr_reader :start_time, :end_time
+
+    def initialize(start_time, end_time=nil)
+      @start_time = start_time
+      @end_time = end_time || start_time
+      __setobj__ @start_time
+    end
+
+    def is_a?(klass)
+      klass == ::Time || super
+    end
+    alias_method :kind_of?, :is_a?
+
+    def intersects? other
+      if other.is_a?(Occurrence) || other.is_a?(Range)
+        lower_bound_1 = first + 1
+        upper_bound_1 = last # exclude end
+        lower_bound_2 = other.first + 1
+        upper_bound_2 = other.last + 1
+        if (lower_bound_2 <=> upper_bound_2) > 0
+          false
+        elsif (lower_bound_1 <=> upper_bound_1) > 0
+          false
+        else
+          (upper_bound_1 <=> lower_bound_2) >= 0 and
+            (upper_bound_2 <=> lower_bound_1) >= 0
+        end
+      else
+        cover? other
+      end
+    end
+
+    def comparable_time
+      start_time
+    end
+
+    def duration
+      end_time - start_time
+    end
+
+    def to_range
+      start_time..end_time
+    end
+
+    def to_time
+      start_time
+    end
+
+    def to_s
+      if duration > 0
+        "#{start_time} - #{end_time}"
+      else
+        "#{start_time}"
+      end
+    end
+
+    def overnight?
+      midnight = Time.new(start_time.year, start_time.month, start_time.day + 1)
+      midnight < end_time
+    end
+  end
+end

data/lib/ice_cube/rule.rb

@@ -48,6 +48,7 @@ module IceCube
       hash = IceCube::FlexibleHash.new original_hash
       return nil unless match = hash[:rule_type].match(/\:\:(.+?)Rule/)
       rule = IceCube::Rule.send(match[1].downcase.to_sym, hash[:interval] || 1)
+      rule.interval(hash[:interval] || 1, TimeUtil.wday_to_sym(hash[:week_start] || 0)) if match[1] == "Weekly"
       rule.until(TimeUtil.deserialize_time(hash[:until])) if hash[:until]
       rule.count(hash[:count]) if hash[:count]
       hash[:validations] && hash[:validations].each do |key, value|

data/lib/ice_cube/schedule.rb

@@ -21,6 +21,7 @@ module IceCube
       self.end_time = options[:end_time] if options[:end_time]
       @all_recurrence_rules = []
       @all_exception_rules = []
+      yield self if block_given?
     end
 
     # Set start_time
@@ -182,16 +183,20 @@ module IceCube
       find_occurrences(begin_time, closing_time)
     end
 
-    # Return a boolean indicating if an occurrence falls between
-    # two times
+    # Return a boolean indicating if an occurrence falls between two times
     def occurs_between?(begin_time, closing_time)
       !find_occurrences(begin_time, closing_time, 1).empty?
     end
 
-    # Return a boolean indicating if an occurrence is occurring between
-    # two times, inclusive
-    def occurring_between?(begin_time, closing_time)
-      occurs_between?(begin_time - duration + 1, closing_time + duration - 1)
+    # Return a boolean indicating if an occurrence is occurring between two
+    # times, inclusive of its duration. This counts zero-length occurrences
+    # that intersect the start of the range and within the range, but not
+    # occurrences at the end of the range since none of their duration
+    # intersects the range.
+    def occurring_between?(opening_time, closing_time)
+      opening_time = opening_time - duration
+      closing_time = closing_time - 1 if duration > 0
+      occurs_between?(opening_time, closing_time)
     end
 
     # Return a boolean indicating if an occurrence falls on a certain date
@@ -265,11 +270,11 @@ module IceCube
     # String serialization
     def to_s
       pieces = []
-      ed = extimes; rd = rtimes - ed
+      rd = recurrence_times_with_start_time - extimes
       pieces.concat rd.sort.map { |t| t.strftime(IceCube.to_s_time_format) }
-      pieces.concat rrules.map { |t| t.to_s }
+      pieces.concat rrules.map  { |t| t.to_s }
       pieces.concat exrules.map { |t| "not #{t.to_s}" }
-      pieces.concat ed.sort.map { |t| "not on #{t.strftime(IceCube.to_s_time_format)}" }
+      pieces.concat extimes.sort.map { |t| "not on #{t.strftime(IceCube.to_s_time_format)}" }
       pieces.join(' / ')
     end
 
@@ -278,9 +283,9 @@ module IceCube
       pieces = []
       pieces << "DTSTART#{IcalBuilder.ical_format(start_time, force_utc)}"
       pieces.concat recurrence_rules.map { |r| "RRULE:#{r.to_ical}" }
-      pieces.concat exception_rules.map { |r| "EXRULE:#{r.to_ical}" }
-      pieces.concat recurrence_times.map { |t| "RDATE#{IcalBuilder.ical_format(t, force_utc)}" }
-      pieces.concat exception_times.map { |t| "EXDATE#{IcalBuilder.ical_format(t, force_utc)}" }
+      pieces.concat exception_rules.map  { |r| "EXRULE:#{r.to_ical}" }
+      pieces.concat recurrence_times_without_start_time.map { |t| "RDATE#{IcalBuilder.ical_format(t, force_utc)}" }
+      pieces.concat exception_times.map  { |t| "EXDATE#{IcalBuilder.ical_format(t, force_utc)}" }
       pieces << "DTEND#{IcalBuilder.ical_format(end_time, force_utc)}" if end_time
       pieces.join("\n")
     end
@@ -292,7 +297,11 @@ module IceCube
 
     # Load the schedule from yaml
     def self.from_yaml(yaml, options = {})
-      from_hash IceCube::use_psych? ? Psych::load(yaml) : YAML::load(yaml), options
+      hash = IceCube::use_psych? ? Psych::load(yaml) : YAML::load(yaml)
+      if match = yaml.match(/start_date: .+((?:-|\+)\d{2}:\d{2})$/)
+        TimeUtil.restore_deserialized_offset(hash[:start_date], match[1])
+      end
+      from_hash hash, options
     end
 
     # Convert the schedule to a hash
@@ -388,33 +397,19 @@ module IceCube
 
     # Get the next time after (or including) a specific time
     def next_time(time, closing_time)
-      min_time = nil
       loop do
-        @all_recurrence_rules.each do |rule|
+        min_time = recurrence_rules_with_implicit_start_occurrence.reduce(nil) do |min_time, rule|
           begin
-            if res = rule.next_time(time, self, closing_time)
-              if min_time.nil? || res < min_time
-                min_time = res
-              end
-            end
-          # Certain exceptions mean this rule no longer wants to play
+            new_time = rule.next_time(time, self, min_time || closing_time)
+            [min_time, new_time].compact.min
           rescue CountExceeded, UntilExceeded
-            next
+            min_time
           end
         end
-        # If there is no match, return nil
-        return nil unless min_time
-        # Now make sure that its not an exception_time, and if it is
-        # then keep looking
-        if exception_time?(min_time)
-          time = min_time + 1
-          min_time = nil
-          next
-        end
-        # Break, we're done
-        break
+        break nil unless min_time
+        next(time = min_time + 1) if exception_time?(min_time)
+        break Occurrence.new(min_time, min_time + duration)
       end
-      min_time
     end
 
     # Return a boolean indicating if any rule needs to be run from the start of time
@@ -431,6 +426,30 @@ module IceCube
       end
     end
 
+    def implicit_start_occurrence
+      SingleOccurrenceRule.new(start_time)
+    end
+
+    def recurrence_times_without_start_time
+      recurrence_times.reject { |t| t == start_time }
+    end
+
+    def recurrence_times_with_start_time
+      if (recurrence_rules).empty?
+        [start_time] + recurrence_times_without_start_time
+      else
+        recurrence_times
+      end
+    end
+
+    def recurrence_rules_with_implicit_start_occurrence
+      if recurrence_rules.empty?
+        [implicit_start_occurrence] + @all_recurrence_rules
+      else
+        @all_recurrence_rules
+      end
+    end
+
   end
 
 end

data/lib/ice_cube/time_step.rb

@@ -0,0 +1,30 @@
+module IceCube
+  class TimeStep
+    SECS   = 1
+    MINS   = 60
+    HOURS  = MINS * 60
+    DAYS   = HOURS * 24
+    WEEKS  = DAYS * 7
+    MONTHS = {
+      1  => [ 28,  29,  30,  31].map { |m| m * DAYS },
+      2  => [ 59,  60,  61,  62].map { |m| m * DAYS },
+      3  => [ 89,  90,  91,  92].map { |m| m * DAYS },
+      4  => [120, 121, 122, 123].map { |m| m * DAYS },
+      5  => [150, 151, 152, 153].map { |m| m * DAYS },
+      6  => [181, 182, 183, 184].map { |m| m * DAYS },
+      7  => [212, 213, 214, 215].map { |m| m * DAYS },
+      8  => [242, 243, 244, 245].map { |m| m * DAYS },
+      9  => [273, 274, 275, 276].map { |m| m * DAYS },
+      10 => [303, 304, 305, 306].map { |m| m * DAYS },
+      11 => [334, 335, 336, 337].map { |m| m * DAYS },
+      12 => [365, 366]          .map { |m| m * DAYS }
+    }
+    YEARS = [365, 366]
+
+    def next(base, validations)
+    end
+
+    def prev(base, validations)
+    end
+  end
+end

data/lib/ice_cube/time_util.rb

@@ -1,11 +1,9 @@
 require 'date'
 
 module IceCube
-
   module TimeUtil
 
-    LEAP_YEAR_MONTH_DAYS = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
-    COMMON_YEAR_MONTH_DAYS = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+    extend ::Deprecated
 
     DAYS = {
       :sunday => 0, :monday => 1, :tuesday => 2, :wednesday => 3,
@@ -40,9 +38,13 @@ module IceCube
     # Ensure that this is either nil, or a time
     def self.ensure_time(time, date_eod = false)
       case time
-      when DateTime then time.to_time
-      when Date then date_eod ? time.to_time.end_of_day : time.to_time
-      else time
+      when DateTime
+        warn "IceCube: DateTime support is deprecated (please use Time)"
+        Time.local(time.year, time.month, time.day, time.hour, time.min, time.sec)
+      when Date
+        date_eod ? end_of_date(time) : time.to_time
+      else
+        time
       end
     end
 
@@ -51,15 +53,14 @@ module IceCube
       case date
       when Date then date
       else
-        return date.to_date if date.respond_to? :to_date
-        return date.to_time.to_date if date.respond_to? :to_time
+        return Date.new(date.year, date.month, date.day)
       end
     end
 
     # Serialize a time appropriate for storing
     def self.serialize_time(time)
-      if defined?(:ActiveSupport) && const_defined?(:ActiveSupport) && time.is_a?(ActiveSupport::TimeWithZone)
-        { :time => time.utc, :zone => time.time_zone.name }
+      if time.respond_to?(:time_zone)
+        {:time => time.utc, :zone => time.time_zone.name}
       elsif time.is_a?(Time)
         time
       end
@@ -74,9 +75,22 @@ module IceCube
       end
     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
+    # keep it.  If it was serialized with a different offset than local TZ it
+    # will lose the zone and not support DST.
+    def self.restore_deserialized_offset(time, orig_offset_str)
+      return time if time.respond_to?(:time_zone) or
+                     time.getlocal(orig_offset_str).utc_offset == time.utc_offset
+      warn 'IceCube: parsed Time from nonlocal TZ. Use ActiveSupport to fix DST'
+      time.localtime(orig_offset_str)
+    end
+
     # Get the beginning of a date
-    def self.beginning_of_date(date, reference=Time.now)
+    def self.beginning_of_date(date, reference=nil)
       args = [date.year, date.month, date.day, 0, 0, 0]
+      reference ||= Time.local(*args)
       if reference.respond_to?(:time_zone) && reference.time_zone
         reference.time_zone.local(*args)
       else
@@ -85,8 +99,9 @@ module IceCube
     end
 
     # Get the end of a date
-    def self.end_of_date(date, reference=Time.now)
+    def self.end_of_date(date, reference=nil)
       args = [date.year, date.month, date.day, 23, 59, 59]
+      reference ||= Time.local(*args)
       if reference.respond_to?(:time_zone) && reference.time_zone
         reference.time_zone.local(*args)
       else
@@ -95,30 +110,30 @@ module IceCube
     end
 
     # Convert a symbol to a numeric month
-    def self.symbol_to_month(sym)
-      month = MONTHS[sym]
-      raise "No such month: #{sym}" unless month
-      month
+    def self.sym_to_month(sym)
+      return wday = sym if (1..12).include? sym
+      MONTHS.fetch(sym) { |k| raise KeyError, "No such month: #{k}" }
     end
+    deprecated_alias :symbol_to_month, :sym_to_month
 
-    # Convert a symbol to a numeric day
-    def self.symbol_to_day(sym)
-      day = DAYS[sym]
-      raise "No such day: #{sym}" unless day
-      day
+    # Convert a symbol to a wday number
+    def self.sym_to_wday(sym)
+      return sym if (0..6).include? sym
+      DAYS.fetch(sym) { |k| raise KeyError, "No such weekday: #{k}" }
     end
+    deprecated_alias :symbol_to_day, :sym_to_wday
 
-    # Convert a symbol to an ical day (SU, MO)
-    def self.week_start(sym)
-      raise "No such day: #{sym}" unless DAYS.keys.include?(sym)
-      day = sym.to_s.upcase[0..1]
-      day
+    # Convert wday number to day symbol
+    def self.wday_to_sym(wday)
+      return sym = wday if DAYS.keys.include? wday
+      DAYS.invert.fetch(wday) { |i| raise KeyError, "No such wday number: #{i}" }
     end
 
     # Convert weekday from base sunday to the schedule's week start.
-    def self.normalize_weekday(daynum, week_start)
-      (daynum - symbol_to_day(week_start)) % 7
+    def self.normalize_wday(wday, week_start)
+      (wday - sym_to_wday(week_start)) % 7
     end
+    deprecated_alias :normalize_weekday, :normalize_wday
 
     # Return the count of the number of times wday appears in the month,
     # and which of those time falls on
@@ -131,67 +146,57 @@ module IceCube
 
     # Get the days in the month for +time
     def self.days_in_month(time)
-      days_in_month_year(time.month, time.year)
+      date = Date.new(time.year, time.month, 1)
+      ((date >> 1) - date).to_i
     end
 
+    # Get the days in the following month for +time
     def self.days_in_next_month(time)
-      # Get the next month
-      year = time.year
-      month = time.month + 1
-      if month > 12
-        month %= 12
-        year += 1
-      end
-      # And then determine
-      days_in_month_year(month, year)
+      date = Date.new(time.year, time.month, 1) >> 1
+      ((date >> 1) - date).to_i
+    end
+
+    # Count the number of days to the same day of the next month without
+    # overflowing shorter months
+    def self.days_to_next_month(time)
+      date = Date.new(time.year, time.month, time.day)
+      (date >> 1) - date
     end
 
-    def self.days_in_month_year(month, year)
-      is_leap?(year) ? LEAP_YEAR_MONTH_DAYS[month - 1] : COMMON_YEAR_MONTH_DAYS[month - 1]
+    # Get a day of the month in the month of a given time without overflowing
+    # into the next month. Accepts days from positive (start of month forward) or
+    # negative (from end of month)
+    def self.day_of_month(value, date)
+      if value.to_i > 0
+        [value, days_in_month(date)].min
+      else
+        [1 + days_in_month(date) + value, 1].max
+      end
     end
 
     # Number of days in a year
     def self.days_in_year(time)
-      is_leap?(time.year) ? 366 : 365
+      date = Date.new(time.year, 1, 1)
+      ((date >> 12) - date).to_i
     end
 
     # Number of days to n years
     def self.days_in_n_years(time, year_distance)
-      sum = 0
-      wrapper = TimeWrapper.new(time)
-      year_distance.times do
-        diy = days_in_year(wrapper.to_time)
-        sum += diy
-        wrapper.add(:day, diy)
-      end
-      sum
+      date = Date.new(time.year, time.month, time.day)
+      ((date >> year_distance * 12) - date).to_i
     end
 
     # The number of days in n months
     def self.days_in_n_months(time, month_distance)
-      # move to a safe spot in the month to make this computation
-      desired_day = time.day
-      time -= IceCube::ONE_DAY * (time.day - 27) if time.day >= 28
-      # move n months ahead
-      sum = 0
-      wrapper = TimeWrapper.new(time)
-      month_distance.times do
-        dim = days_in_month(wrapper.to_time)
-        sum += dim
-        wrapper.add(:day, dim)
-      end
-      # now we can move to the desired day
-      dim = days_in_month(wrapper.to_time)
-      if desired_day > dim
-        sum -= desired_day - dim
-      end
-      sum
+      date = Date.new(time.year, time.month, time.day)
+      ((date >> month_distance) - date).to_i
     end
 
-    # Given a year, return a boolean indicating whether it is
-    # a leap year or not
-    def self.is_leap?(year)
-      (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)
+    def self.dst_change(time)
+      one_hour_ago = time - ONE_HOUR
+      if time.dst? ^ one_hour_ago.dst?
+        (time.utc_offset - one_hour_ago.utc_offset) / ONE_HOUR
+      end
     end
 
     # A utility class for safely moving time around
@@ -248,20 +253,20 @@ module IceCube
       end
 
       def clear_sec
-        @time -= @time.sec
+        @time.sec > 0 ? @time -= @time.sec : @time
       end
 
       def clear_min
-        @time -= (@time.min * ONE_MINUTE)
+        @time.min > 0 ? @time -= (@time.min * ONE_MINUTE) : @time
       end
 
       def clear_hour
-        @time -= (@time.hour * ONE_HOUR)
+        @time.hour > 0 ? @time -= (@time.hour * ONE_HOUR) : @time
       end
 
       # Move to the first of the month, 0 hours
       def clear_day
-        @time -= (@time.day - 1) * IceCube::ONE_DAY
+        @time.day > 1 ? @time -= (@time.day - 1) * ONE_DAY : @time
       end
 
       # Clear to january 1st
@@ -274,10 +279,10 @@ module IceCube
       end
 
       def clear_year
+        @time
       end
 
     end
 
   end
-
 end

data/lib/ice_cube/validated_rule.rb

@@ -16,21 +16,28 @@ module IceCube
     include Validations::Count
     include Validations::Until
 
+    # Validations ordered for efficiency in sequence of:
+    # * descending intervals
+    # * boundary limits
+    # * base values by cardinality (n = 60, 60, 31, 24, 12, 7)
+    # * locks by cardinality (n = 365, 60, 60, 31, 24, 12, 7)
+    # * interval multiplier
+    VALIDATION_ORDER = [
+      :year, :month, :day, :wday, :hour, :min, :sec, :count, :until,
+      :base_sec, :base_min, :base_day, :base_hour, :base_month, :base_wday,
+      :day_of_year, :second_of_minute, :minute_of_hour, :day_of_month,
+      :hour_of_day, :month_of_year, :day_of_week,
+      :interval
+    ]
+
     # Compute the next time after (or including) the specified time in respect
     # to the given schedule
     def next_time(time, schedule, closing_time)
       @time = time
       @schedule = schedule
 
-      until finds_acceptable_time?
-        # Prevent a non-matching infinite loop
-        return nil if closing_time && @time.to_i > closing_time.to_i
-      end
+      return nil unless find_acceptable_time_before(closing_time)
 
-      # NOTE Uses may be 1 higher than proper here since end_time isn't
-      # validated in this class.  This is okay now, since we never expose it -
-      # but if we ever do - we should check that above this line, and return
-      # nil if end_time is past
       @uses += 1 if @time
       @time
     end
@@ -89,14 +96,19 @@ module IceCube
 
     private
 
-    # NOTE: optimization target, sort the rules by their type, year first
-    # so we can make bigger jumps more often
     def finds_acceptable_time?
-      @validations.all? do |name, validations_for_type|
-        validation_accepts_or_updates_time?(validations_for_type)
+      validation_names.all? do |type|
+        validation_accepts_or_updates_time?(@validations[type])
       end
     end
 
+    def find_acceptable_time_before(boundary)
+      until finds_acceptable_time?
+        return false if past_closing_time?(boundary)
+      end
+      true
+    end
+
     def validation_accepts_or_updates_time?(validations_for_type)
       res = validated_results(validations_for_type)
       # If there is any nil, then we're set - otherwise choose the lowest
@@ -136,6 +148,14 @@ module IceCube
       @time = wrapper.to_time
     end
 
+    def past_closing_time?(closing_time)
+      closing_time && @time > closing_time
+    end
+
+    def validation_names
+      VALIDATION_ORDER & @validations.keys
+    end
+
   end
 
 end

data/lib/ice_cube/validations/day.rb

@@ -6,7 +6,7 @@ module IceCube
 
     def day(*days)
       days.each do |day|
-        day = TimeUtil.symbol_to_day(day) if day.is_a?(Symbol)
+        day = TimeUtil.sym_to_wday(day)
         validations_for(:day) << Validation.new(day)
       end
       clobber_base_validations(:wday, :day)

data/lib/ice_cube/validations/day_of_week.rb

@@ -5,7 +5,7 @@ module IceCube
     def day_of_week(dows)
       dows.each do |day, occs|
         occs.each do |occ|
-          day = TimeUtil.symbol_to_day(day) if day.is_a?(Symbol)
+          day = TimeUtil.sym_to_wday(day)
           validations_for(:day_of_week) << Validation.new(day, occ)
         end
       end
@@ -18,7 +18,7 @@ module IceCube
       attr_reader :day, :occ
 
       StringBuilder.register_formatter(:day_of_week) do |segments|
-        'on the ' + segments.join(' when it is the ')
+        'on the ' + segments.join(' and ')
       end
 
       def type

data/lib/ice_cube/validations/lock.rb

@@ -5,7 +5,8 @@ module IceCube
 
   module Validations::Lock
 
-    INTERVALS = { :hour => 24, :min => 60, :sec => 60, :month => 12, :wday => 7 }
+    INTERVALS = {:min => 60, :sec => 60, :month => 12, :wday => 7}
+
     def validate(time, schedule)
       return send(:"validate_#{type}_lock", time, schedule) unless INTERVALS[type]
       start = value || schedule.start_time.send(type)
@@ -15,31 +16,57 @@ module IceCube
 
     private
 
-    # Needs to be custom since we don't know the days in the month
-    # (meaning, its not a fixed interval)
-    def validate_day_lock(time, schedule)
-      start = value || schedule.start_time.day
-      days_in_this_month = TimeUtil.days_in_month(time)
-      # If this number is positive, then follow our normal procedure
-      if start > 0
-        return start >= time.day ? start - time.day : days_in_this_month - time.day + start
+    # 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)
+      hour = value || schedule.start_time.send(type)
+      hour = 24 + hour if hour < 0
+      if hour >= time.hour
+        hour - time.hour
+      else
+        if dst_offset = TimeUtil.dst_change(time)
+          hour - time.hour + dst_offset
+        else
+          24 - time.hour + hour
+        end
       end
-      # If the number is negative, and it resolved against the current month
-      # puts it in the future, just return the difference
-      days_in_this_month = TimeUtil.days_in_month(time)
-      start_one = days_in_this_month + start + 1
-      if start_one >= time.day
-        return start_one - time.day
+    end
+
+    # For monthly rules that have no specified day value, the validation relies
+    # on the schedule start time and jumps to include every month even if it
+    # has fewer days than the schedule's start day.
+    #
+    # Negative day values (from month end) also include all months.
+    #
+    # Positive day values are taken literally so months with fewer days will
+    # be skipped.
+    #
+    def validate_day_lock(time, schedule)
+      days_in_month = TimeUtil.days_in_month(time)
+      date = Date.new(time.year, time.month, time.day)
+
+      if value && value < 0
+        start = TimeUtil.day_of_month(value, date)
+        month_overflow = days_in_month - TimeUtil.days_in_next_month(time)
+      elsif value && value > 0
+        start = value
+        month_overflow = 0
+      else
+        start = TimeUtil.day_of_month(schedule.start_time.day, date)
+        month_overflow = 0
       end
-      # Otherwise, we need to figure out the meaning of the value
-      # in the next month, and then figure out how to get there
-      days_in_next_month = TimeUtil.days_in_next_month(time)
-      start_two = days_in_next_month + start + 1
-      if start_two >= time.day
-        days_in_this_month + start_two - time.day
+
+      sleeps = start - date.day
+
+      if value && value > 0
+        until_next_month = days_in_month + sleeps
       else
-        days_in_next_month + start_two - time.day
+        until_next_month = TimeUtil.days_to_next_month(date) + sleeps
+        until_next_month -= month_overflow
       end
+
+      sleeps >= 0 ? sleeps : until_next_month
     end
 
   end

data/lib/ice_cube/validations/month_of_year.rb

@@ -4,7 +4,7 @@ module IceCube
 
     def month_of_year(*months)
       months.each do |month|
-        month = TimeUtil.symbol_to_month(month) if month.is_a?(Symbol)
+        month = TimeUtil.sym_to_month(month)
         validations_for(:month_of_year) << Validation.new(month)
       end
       clobber_base_validations :month

data/lib/ice_cube/validations/schedule_lock.rb

@@ -34,6 +34,12 @@ module IceCube
       def build_hash(builder)
       end
 
+      def dst_adjust?
+        case @type
+        when :sec, :min then false
+        else true
+        end
+      end
     end
 
   end

data/lib/ice_cube/validations/weekly_interval.rb

@@ -6,11 +6,16 @@ module IceCube
 
     def interval(interval, week_start = :sunday)
       @interval = interval
+      @week_start = TimeUtil.wday_to_sym(week_start)
       validations_for(:interval) << Validation.new(interval, week_start)
       clobber_base_validations(:day)
       self
     end
 
+    def week_start
+      @week_start
+    end
+
     class Validation
 
       attr_reader :interval, :week_start
@@ -27,12 +32,13 @@ module IceCube
         builder['FREQ'] << 'WEEKLY'
         unless interval == 1
           builder['INTERVAL'] << interval
-          builder['WKST'] << TimeUtil.week_start(week_start)
+          builder['WKST'] << week_start.to_s.upcase[0..1]
         end
       end
 
       def build_hash(builder)
         builder[:interval] = interval
+        builder[:week_start] = TimeUtil.sym_to_wday(week_start)
       end
 
       def initialize(interval, week_start)
@@ -45,8 +51,8 @@ module IceCube
         st = schedule.start_time
         start_date = Date.new(st.year, st.month, st.day)
         weeks = (
-          (date - TimeUtil.normalize_weekday(date.wday, week_start)) -
-          (start_date - TimeUtil.normalize_weekday(start_date.wday, week_start))
+          (date - TimeUtil.normalize_wday(date.wday, week_start)) -
+          (start_date - TimeUtil.normalize_wday(start_date.wday, week_start))
         ) / 7
         unless weeks % interval == 0
           (interval - (weeks % interval)) * 7

data/lib/ice_cube/version.rb

@@ -1,5 +1,5 @@
 module IceCube
 
-  VERSION = '0.9.3'
+  VERSION = '0.10.0'
 
 end

data/spec/spec_helper.rb

@@ -9,3 +9,43 @@ require File.dirname(__FILE__) + '/../lib/ice_cube'
 
 DAY = Time.utc(2010, 3, 1)
 WEDNESDAY = Time.utc(2010, 6, 23, 5, 0, 0)
+WORLD_TIME_ZONES = [
+  'America/Anchorage',  # -1000 / -0900
+  'Europe/London',      # +0000 / +0100
+  'Pacific/Auckland',   # +1200 / +1300
+]
+
+RSpec.configure do |config|
+
+  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
+    end
+  end
+
+  config.around :each do |example|
+    if zone = example.metadata[:system_time_zone]
+      @orig_zone = ENV['TZ']
+      ENV['TZ'] = zone
+      example.run
+      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
+end

metadata

@@ -1,78 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: ice_cube
 version: !ruby/object:Gem::Version
-  version: 0.9.3
-  prerelease: 
+  version: 0.10.0
 platform: ruby
 authors:
 - John Crepezzi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-03 00:00:00.000000000 Z
+date: 2013-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: active_support
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 3.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: tzinfo
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: ice_cube is a recurring date library for Ruby.  It allows for quick,
@@ -89,6 +80,7 @@ files:
 - lib/ice_cube/errors/count_exceeded.rb
 - lib/ice_cube/errors/until_exceeded.rb
 - lib/ice_cube/flexible_hash.rb
+- lib/ice_cube/occurrence.rb
 - lib/ice_cube/rule.rb
 - lib/ice_cube/rules/daily_rule.rb
 - lib/ice_cube/rules/hourly_rule.rb
@@ -99,6 +91,7 @@ files:
 - lib/ice_cube/rules/yearly_rule.rb
 - lib/ice_cube/schedule.rb
 - lib/ice_cube/single_occurrence_rule.rb
+- lib/ice_cube/time_step.rb
 - lib/ice_cube/time_util.rb
 - lib/ice_cube/validated_rule.rb
 - lib/ice_cube/validations/count.rb
@@ -124,28 +117,28 @@ files:
 - lib/ice_cube.rb
 - spec/spec_helper.rb
 homepage: http://seejohnrun.github.com/ice_cube/
-licenses: []
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: ice-cube
-rubygems_version: 1.8.24
+rubygems_version: 2.0.0
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Ruby Date Recurrence Library
 test_files:
 - spec/spec_helper.rb