ice_cube 0.11.3 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ec72afe66473b31f58d02177fce834635b8d6f6d
-  data.tar.gz: f2b199ad1c5cddfbdc4f0b435f7caa594e8e0f3b
+  metadata.gz: f8d575d65663825eb9be2a82f9e931537009d485
+  data.tar.gz: 2e292c2f229a8a7b7aaaf8f8dcaf009412741745
 SHA512:
-  metadata.gz: 21eba9fafa80dd036ca6e24f118b4638c46c68000a1a77758467d8cc1a27b9cb0c287980fe2d23fbaeb0b18f35d7ac9f8c6850bb5ff5a5cd2c019dace00d9f43
-  data.tar.gz: 2d842dc82d6f195642c2ecfd0bb4198dd6d9dced764da87bba2001309d2d4de4672f581c8e3ddc062223c87e9c32c1cb32aa2874cb4a1e4893ba98f578ce73fc
+  metadata.gz: 98e4ffa4ddc22fb26da6eb632203e389361149216ad62193f64c773fe1a68da07dff80ab3f0470cbc1d0dabfc049780b86eb4f270469b2e47539e46016709c1e
+  data.tar.gz: 2882dc6f6af47db013a1ee079c2fc06ecf254274b0d39b00f24bc6a8e72021b4935e27463a65ab7c01740180bcab4236bfc15507825b3db910b4bf16f5ab6ce3

data/lib/ice_cube.rb

@@ -16,6 +16,9 @@ module IceCube
   autoload :HashBuilder, 'ice_cube/builders/hash_builder'
   autoload :StringBuilder, 'ice_cube/builders/string_builder'
 
+  autoload :HashParser, 'ice_cube/parsers/hash_parser'
+  autoload :YamlParser, 'ice_cube/parsers/yaml_parser'
+
   autoload :CountExceeded, 'ice_cube/errors/count_exceeded'
   autoload :UntilExceeded, 'ice_cube/errors/until_exceeded'
 
@@ -74,4 +77,14 @@ module IceCube
   def self.to_s_time_format=(format)
     @to_s_time_format = format
   end
+
+  # Retain backwards compatibility for schedules exported from older versions
+  # This represents the version number, 11 = 0.11, 1.0 will be 100
+  def self.compatibility
+    @compatibility ||= 11
+  end
+
+  def self.compatibility=(version)
+    @compatibility = version
+  end
 end

data/lib/ice_cube/deprecated.rb

@@ -26,5 +26,13 @@ module IceCube
 			end
 		end
 
+    def self.schedule_options(schedule, options)
+      if options[:start_date_override]
+        warn "IceCube: :start_date_override option deprecated. " \
+          "(please use a block { |s| s.start_time = override })"
+        schedule.start_time = options[:start_date_override]
+      end
+    end
+
 	end
 end

data/lib/ice_cube/enumerator.rb

@@ -0,0 +1,63 @@
+module IceCube
+  class Enumerator < ::Enumerator
+
+    def initialize(schedule, from_time, to_time)
+      @schedule  = schedule
+      @from_time = TimeUtil.ensure_time(from_time)
+      @to_time   = TimeUtil.ensure_time(to_time)
+      align_start_time
+      @cursor = @from_time
+    end
+
+    def each
+      while res = self.find_next && @to_time.nil? || res <= @to_time
+        yield Occurrence.new(res, res + schedule.duration)
+      end
+      raise StopIteration
+    end
+
+    def find_next
+      loop do
+        min_time = recurrence_rules.reduce(nil) do |min_time, rule|
+          catch :limit do
+            new_time = rule.next_time(time, schedule, min_time || @to_time)
+            [min_time, new_time].compact.min
+          end
+        end
+        break nil unless min_time
+        @cursor = min_time + 1
+        next if exception_time?(min_time)
+        break min_time
+      end
+    end
+
+    private
+
+    def align_start_time
+      if @from_time <= schedule.start_time || full_required?
+        @from_time = schedule.start_time
+      else
+        @from_time += @schedule.start_time.subsec - @from_time.subsec rescue 0
+      end
+    end
+
+    # Return a boolean indicating if any rule needs to be run from the start of time
+    def full_required?
+      recurrence_rules.any?(&:full_required?) ||
+      exception_rules.any?(&:full_required?)
+    end
+
+    def exception_rules
+      schedule.instance_variable_get(:@all_exception_rules)
+    end
+
+    def recurrence_rules
+      @recurrence_rules ||= if recurrence_rules.empty?
+        [SingleOccurrenceRule.new(schedule.start_time)].concat schedule.instance_variable_get(:@all_recurrence_rules)
+      else
+        schedule.instance_variable_get(:@all_recurrence_rules)
+      end
+    end
+
+  end
+end

data/lib/ice_cube/errors/count_exceeded.rb

@@ -1,7 +1,7 @@
 module IceCube
 
   # An exception for when a count on a Rule is passed
-  class CountExceeded < Exception
+  class CountExceeded < StopIteration
   end
 
 end

data/lib/ice_cube/errors/until_exceeded.rb

@@ -1,7 +1,7 @@
 module IceCube
 
   # An exception for when an until date on a Rule is passed
-  class UntilExceeded < Exception
+  class UntilExceeded < StopIteration
   end
 
 end

data/lib/ice_cube/flexible_hash.rb

@@ -2,21 +2,37 @@ require 'delegate'
 
 module IceCube
 
-  # A way to symbolize what's necessary on the fly
+  # Find keys by symbol or string without symbolizing user input
   # Due to the serialization format of ice_cube, this limited implementation
   # is entirely sufficient
 
   class FlexibleHash < SimpleDelegator
 
-    def initialize(hash)
-      @underlying = hash
+    def [](key)
+      key = _match_key(key)
+      super
     end
 
-    def [](key)
-      case key
-      when String then @underlying[key] || @underlying[key.to_sym]
-      else @underlying[key] || @underlying[key.to_s]
+    def fetch(key)
+      key = _match_key(key)
+      super
+    end
+
+    def delete(key)
+      key = _match_key(key)
+      super
+    end
+
+    private
+
+    def _match_key(key)
+      return key if __getobj__.has_key? key
+      if Symbol == key.class
+        __getobj__.keys.detect { |k| return k if k == key.to_s }
+      elsif String == key.class
+        __getobj__.keys.detect { |k| return k if k.to_s == key }
       end
+      key
     end
 
   end

data/lib/ice_cube/formatters/string.rb

@@ -0,0 +1,155 @@
+class IceCube::StringBuilder
+
+  format :day do |entries|
+    case entries = entries.sort
+    when [0, 6]          then 'on Weekends'
+    when [1, 2, 3, 4, 5] then 'on Weekdays'
+    else
+      "on " << build(:sentence, build(:daynames, entries))
+    end
+  end
+
+  format :dayname do |number|
+    Date::DAYNAMES[number]
+  end
+
+  format :daynames do |entries|
+    entries.map { |wday| build(:dayname, wday) + "s" }
+  end
+
+  format :monthnames do |entries|
+    entries.map { |m| Date::MONTHNAMES[m] }
+  end
+
+  format :count do |number|
+    times = number == 1 ? "time" : "times"
+    "#{number} #{times}"
+  end
+
+  format :day_of_month do |entries|
+    numbered = build(:sentence, build(:ordinals, entries))
+    days = entries.size == 1 ? "day" : "days"
+    "on the #{numbered} #{days} of the month"
+  end
+
+  format :day_of_week do |entries|
+    numbered_weekdays = build(:daynames_of_week, entries).join(" and ")
+    "on the #{numbered_weekdays}"
+  end
+
+  format :daynames_of_week do |entries|
+    entries.map do |occurrence, wday|
+      numbered = build(:ordinal, occurrence)
+      weekday  = build(:dayname, wday)
+      "#{numbered} #{weekday}"
+    end
+  end
+
+  format :day_of_year do |entries|
+    numbered = build(:sentence, build(:ordinals, entries))
+    days = entries.size == 1 ? "day" : "days"
+    "on the #{numbered} #{days} of the year"
+  end
+
+  format :hour_of_day do |entries|
+    numbered = build(:sentence, build(:ordinals, entries))
+    hours = entries.size == 1 ? "hour" : "hours"
+    "on the #{numbered} #{hours} of the day"
+  end
+
+  format :minute_of_hour do |entries|
+    numbered = build(:sentence, build(:ordinals, entries))
+    minutes = entries.size == 1 ? "minute" : "minutes"
+    "on the #{numbered} #{minutes} of the hour"
+  end
+
+  format :month_of_year do |entries|
+    "in " << build(:sentence, build(:monthnames, entries))
+  end
+
+  format :second_of_minute do |entries|
+    numbered = build(:sentence, build(:ordinals, entries))
+    seconds = entries.size == 1 ? "second" : "seconds"
+    "on the #{numbered} #{seconds} of the minute"
+  end
+
+  format :time do |time|
+    time.strftime(IceCube.to_s_time_format)
+  end
+
+  format :until do |time|
+    "until " << build(:time, time)
+  end
+
+  format :sentence do |entries|
+    case entries.length
+    when 0 then ''
+    when 1 then entries[0].to_s
+    when 2 then "#{entries[0]} and #{entries[1]}"
+    else "#{entries[0...-1].join(', ')}, and #{entries[-1]}"
+    end
+  end
+
+  format :ordinals do |entries|
+    entries = entries.sort
+    entries.rotate! while entries[0] < 0 if entries.last > 0
+    entries.map { |number| build(:ordinal, number) }
+  end
+
+  format :ordinal do |number|
+    next "last" if number == -1
+    suffix = SPECIAL_SUFFIX[number] || NUMBER_SUFFIX[number.abs % 10]
+    if number < -1
+      number.abs.to_s << suffix << " to last"
+    else
+      number.to_s << suffix
+    end
+  end
+
+  format :daily_interval do |i|
+    i == 1 ? "Daily" : "Every #{i} days"
+  end
+
+  format :hourly_interval do |i|
+    i == 1 ? "Hourly" : "Every #{i} hours"
+  end
+
+  format :minutely_interval do |i|
+    i == 1 ? "Minutely" : "Every #{i} minutes"
+  end
+
+  format :monthly_interval do |i|
+    i == 1 ? "Monthly" : "Every #{i} months"
+  end
+
+  format :secondly_interval do |i|
+    i == 1 ? "Secondly" : "Every #{i} seconds"
+  end
+
+  format :weekly_interval do |i|
+    i == 1 ? "Weekly" : "Every #{i} weeks"
+  end
+
+  format :yearly_interval do |i|
+    i == 1 ? "Yearly" : "Every #{i} years"
+  end
+
+  format :exrule do |rule|
+    "not #{rule}"
+  end
+
+  format :extime do |time|
+    "not on #{build(:time, time)}"
+  end
+
+  format :schedule do |s|
+    times = s.recurrence_times_with_start_time - s.extimes
+    pieces = []
+    pieces.concat times.uniq.sort.map     { |t| build(:time, t) }
+    pieces.concat s.rrules.map            { |t| t.to_s }
+    pieces.concat s.exrules.map           { |t| build(:exrule, t) }
+    pieces.concat s.extimes.uniq.sort.map { |t| build(:extime, t) }
+    pieces.join(' / ')
+  end
+
+end

data/lib/ice_cube/hash_input.rb

@@ -0,0 +1,71 @@
+module IceCube
+  class HashInput
+
+    class Mash
+      def initialize(hash)
+        @hash = hash
+      end
+
+      # Fetch values indifferently by symbol or string key without symbolizing
+      # arbitrary string input
+      #
+      def [](key)
+        @hash.fetch(key) do |key|
+          str_key = key.to_s
+          @hash.each_pair.detect do |sym_key, value|
+            return value if sym_key.to_s == str_key
+          end
+        end
+      end
+    end
+
+    def initialize(hash)
+      @input = Mash.new(hash)
+    end
+
+    def [](key)
+      @input[key]
+    end
+
+    def to_rule
+      return nil unless rule_class
+      rule = rule_class.new(interval, week_start)
+      rule.until(limit_time) if limit_time
+      rule.count(limit_count) if limit_count
+      validations.each do |validation, args|
+        rule.send(validation, *args)
+      end
+    end
+
+    def rule_class
+      return @rule_class if @rule_class
+      match = @input[:rule_type].match(/::(\w+Rule)$/)
+      @rule_class = IceCube.const_get(match[1]) if match
+    end
+
+    def interval
+      @input[:interval] || 1
+    end
+
+    def week_start
+      @input[:week_start] || :sunday
+    end
+
+    def limit_time
+      @limit_time ||= TimeUtil.deserialize_time(@input[:until])
+    end
+
+    def limit_count
+      @input[:count]
+    end
+
+    def validations
+      input_validations = Mash.new(@input[:validations] || {})
+      ValidatedRule::VALIDATION_ORDER.each_with_object({}) do |key, output_validations|
+        args = input_validations[key]
+        output_validations[key] = Array(args) if args
+      end
+    end
+
+  end
+end

data/lib/ice_cube/occurrence.rb

@@ -93,7 +93,8 @@ module IceCube
     end
 
     def overnight?
-      midnight = Time.new(start_time.year, start_time.month, start_time.day + 1)
+      offset = start_time + 3600 * 24
+      midnight = Time.new(offset.year, offset.month, offset.day)
       midnight < end_time
     end
   end

data/lib/ice_cube/parsers/hash_parser.rb

@@ -0,0 +1,87 @@
+module IceCube
+  class HashParser
+
+    attr_reader :hash
+
+    def initialize(original_hash)
+      @hash = original_hash
+    end
+
+    def to_schedule
+      data = normalize_keys(hash)
+      schedule = IceCube::Schedule.new parse_time(data[:start_time])
+      apply_duration schedule, data
+      apply_end_time schedule, data
+      apply_rrules schedule, data
+      apply_exrules schedule, data
+      apply_rtimes schedule, data
+      apply_extimes schedule, data
+      yield schedule if block_given?
+      schedule
+    end
+
+    private
+
+    def normalize_keys(hash)
+      data = IceCube::FlexibleHash.new(hash.dup)
+
+      if (start_date = data.delete(:start_date))
+				warn "IceCube: :start_date deprecated. (please use :start_time)"
+        data[:start_time] = start_date
+      end
+
+      {:rdates => :rtimes, :exdates => :extimes}.each do |old_key, new_key|
+        if (times = data.delete(old_key))
+          warn "IceCube: :#{old_key} deprecated. (please use :#{new_key})"
+          (data[new_key] ||= []).concat times
+        end
+      end
+
+      data
+    end
+
+    def apply_duration(schedule, data)
+      return unless data[:duration]
+      schedule.duration = data[:duration].to_i
+    end
+
+    def apply_end_time(schedule, data)
+      return unless data[:end_time]
+      schedule.end_time = parse_time(data[:end_time])
+    end
+
+    def apply_rrules(schedule, data)
+      return unless data[:rrules]
+      data[:rrules].each do |h|
+        schedule.rrule(IceCube::Rule.from_hash(h))
+      end
+    end
+
+    def apply_exrules(schedule, data)
+      return unless data[:exrules]
+      warn "IceCube: :exrules deprecated. (This will be going away)"
+      data[:exrules].each do |h|
+        schedule.exrule(IceCube::Rule.from_hash(h))
+      end
+    end
+
+    def apply_rtimes(schedule, data)
+      return unless data[:rtimes]
+      data[:rtimes].each do |t|
+        schedule.add_recurrence_time TimeUtil.deserialize_time(t)
+      end
+    end
+
+    def apply_extimes(schedule, data)
+      return unless data[:extimes]
+      data[:extimes].each do |t|
+        schedule.add_exception_time TimeUtil.deserialize_time(t)
+      end
+    end
+
+    def parse_time(time)
+      TimeUtil.deserialize_time(time)
+    end
+
+  end
+end

data/lib/ice_cube/parsers/yaml_parser.rb

@@ -0,0 +1,21 @@
+module IceCube
+  class YamlParser < HashParser
+
+    SERIALIZED_START = /start_(?:time|date): .+(?<tz>(?:-|\+)\d{2}:\d{2})$/
+
+    attr_reader :hash
+
+    def initialize(yaml)
+      @hash = YAML::load(yaml)
+      yaml.match(SERIALIZED_START) do |match|
+        start_time = hash[:start_time] || hash[:start_date]
+        hash = FlexibleHash.new(@hash)
+        TimeUtil.restore_deserialized_offset start_time, match[:tz]
+      end
+    end
+
+    private
+
+
+  end
+end

data/lib/ice_cube/schedule.rb

@@ -153,7 +153,7 @@ module IceCube
       require_terminating_rules
       enumerate_occurrences(start_time).to_a
     end
-    
+
     # Emit an enumerator based on the start time
     def all_occurrences_enumerator
       enumerate_occurrences(start_time)
@@ -340,20 +340,22 @@ module IceCube
 
     # Load the schedule from yaml
     def self.from_yaml(yaml, options = {})
-      hash = YAML::load(yaml)
-      if match = yaml.match(/start_date: .+((?:-|\+)\d{2}:\d{2})$/)
-        TimeUtil.restore_deserialized_offset(hash[:start_date], match[1])
+      YamlParser.new(yaml).to_schedule do |schedule|
+        Deprecated.schedule_options(schedule, options)
+        yield schedule if block_given?
       end
-      from_hash hash, options
     end
 
     # Convert the schedule to a hash
     def to_hash
       data = {}
-      data[:start_date] = TimeUtil.serialize_time(start_time)
+      data[:start_time] = TimeUtil.serialize_time(start_time)
+      data[:start_date] = data[:start_time] if IceCube.compatibility <= 11
       data[:end_time] = TimeUtil.serialize_time(end_time) if end_time
       data[:rrules] = recurrence_rules.map(&:to_hash)
-      data[:exrules] = exception_rules.map(&:to_hash)
+      if IceCube.compatibility <= 11 && exception_rules.any?
+        data[:exrules] = exception_rules.map(&:to_hash)
+      end
       data[:rtimes] = recurrence_times.map do |rt|
         TimeUtil.serialize_time(rt)
       end
@@ -365,28 +367,10 @@ module IceCube
 
     # Load the schedule from a hash
     def self.from_hash(original_hash, options = {})
-      original_hash[:start_date] = options[:start_date_override] if options[:start_date_override]
-      # And then deserialize
-      data = IceCube::FlexibleHash.new(original_hash)
-      schedule = IceCube::Schedule.new TimeUtil.deserialize_time(data[:start_date])
-      schedule.end_time = schedule.start_time + data[:duration] if data[:duration]
-      schedule.end_time = TimeUtil.deserialize_time(data[:end_time]) if data[:end_time]
-      data[:rrules] && data[:rrules].each { |h| schedule.rrule(IceCube::Rule.from_hash(h)) }
-      data[:exrules] && data[:exrules].each { |h| schedule.exrule(IceCube::Rule.from_hash(h)) }
-      data[:rtimes] && data[:rtimes].each do |t|
-        schedule.add_recurrence_time TimeUtil.deserialize_time(t)
-      end
-      data[:extimes] && data[:extimes].each do |t|
-        schedule.add_exception_time TimeUtil.deserialize_time(t)
-      end
-      # Also serialize old format for backward compat
-      data[:rdates] && data[:rdates].each do |t|
-        schedule.add_recurrence_time TimeUtil.deserialize_time(t)
-      end
-      data[:exdates] && data[:exdates].each do |t|
-        schedule.add_exception_time TimeUtil.deserialize_time(t)
+      HashParser.new(original_hash).to_schedule do |schedule|
+        Deprecated.schedule_options(schedule, options)
+        yield schedule if block_given?
       end
-      schedule
     end
 
     # Determine if the schedule will end
@@ -413,25 +397,27 @@ 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, &block)
-      opening_time = TimeUtil.ensure_time opening_time
-      closing_time = TimeUtil.ensure_time closing_time
+      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
       reset
       opening_time = start_time if opening_time < start_time
-      # walk up to the opening time - and off we go
-      # If we have rules with counts, we need to walk from the beginning of time,
-      # otherwise opening_time
-      time = full_required? ? start_time : opening_time
+      t1 = full_required? ? start_time : opening_time
       e = Enumerator.new do |yielder|
         loop do
-          res = next_time(time, closing_time)
-          break unless res
-          break if closing_time && res > closing_time
-          if res >= opening_time
-            yielder.yield (block_given? ? block.call(res) : res)
+          break unless (t0 = next_time(t1, closing_time))
+          break if closing_time && t0 > closing_time
+          yielder << (block_given? ? block.call(t0) : t0) if t0 >= opening_time
+          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)
           end
-          time = res + 1
+          yielder << (block_given? ? block.call(t1) : t1) if t1 >= opening_time
+          next (t1 += 1)
         end
       end
     end
@@ -443,17 +429,18 @@ module IceCube
           begin
             new_time = rule.next_time(time, self, min_time || closing_time)
             [min_time, new_time].compact.min
-          rescue CountExceeded, UntilExceeded
+          rescue StopIteration
             min_time
           end
         end
         break nil unless min_time
-        next(time = min_time + 1) if exception_time?(min_time)
+        next (time = min_time + 1) if exception_time?(min_time)
         break Occurrence.new(min_time, min_time + duration)
       end
     end
 
-    # Return a boolean indicating if any rule needs to be run from the start of time
+    # Indicate if any rule needs to be run from the start of time
+    # If we have rules with counts, we need to walk from the beginning of time
     def full_required?
       @all_recurrence_rules.any?(&:full_required?) ||
       @all_exception_rules.any?(&:full_required?)
@@ -497,6 +484,12 @@ 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/string_helpers.rb

@@ -0,0 +1,10 @@
+module IceCube
+  module StringHelpers
+
+    module_function
+
+    def nice_number(number)
+    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

@@ -16,6 +16,8 @@ module IceCube
       :november => 11, :december => 12
     }
 
+    CLOCK_VALUES = [:year, :month, :day, :hour, :min, :sec]
+
     # Provides a Time.now without the usec, in the reference zone or utc offset
     def self.now(reference=Time.now)
       match_zone(Time.at(Time.now.to_i), reference)
@@ -72,7 +74,8 @@ module IceCube
       if time_or_hash.is_a?(Time)
         time_or_hash
       elsif time_or_hash.is_a?(Hash)
-        time_or_hash[:time].in_time_zone(time_or_hash[:zone])
+        hash = FlexibleHash.new(time_or_hash)
+        hash[:time].in_time_zone(hash[:zone])
       end
     end
 
@@ -112,8 +115,8 @@ module IceCube
 
     # Convert a symbol to a numeric month
     def self.sym_to_month(sym)
-      return wday = sym if (1..12).include? sym
       MONTHS.fetch(sym) do |k|
+        return wday = sym.to_i if MONTHS.values.any? { |i| i.to_s == sym.to_s }
         raise ArgumentError, "Expecting Fixnum or Symbol value for month. " \
                              "No such month: #{k.inspect}"
       end
@@ -122,8 +125,8 @@ module IceCube
 
     # Convert a symbol to a wday number
     def self.sym_to_wday(sym)
-      return sym if (0..6).include? sym
       DAYS.fetch(sym) do |k|
+        return sym.to_i if DAYS.values.any? { |i| i.to_s == sym.to_s }
         raise ArgumentError, "Expecting Fixnum or Symbol value for weekday. " \
                              "No such weekday: #{k.inspect}"
       end
@@ -209,6 +212,10 @@ module IceCube
       end
     end
 
+    def self.same_clock?(t1, t2)
+      CLOCK_VALUES.all? { |i| t1.send(i) == t2.send(i) }
+    end
+
     # A utility class for safely moving time around
     class TimeWrapper
 

data/lib/ice_cube/validated_rule.rb

@@ -46,6 +46,14 @@ module IceCube
       @time
     end
 
+    def skipped_for_dst
+      @uses -= 1 if @uses > 0
+    end
+
+    def dst_adjust?
+      @validations[:interval].any? &:dst_adjust?
+    end
+
     def to_s
       builder = StringBuilder.new
       @validations.each do |name, validations|
@@ -132,12 +140,11 @@ module IceCube
     end
 
     def shift_time_by_validation(res, vals)
-      return unless res.min
-      type = vals.first.type # get the jump type
-      dst_adjust = !vals.first.respond_to?(:dst_adjust?) || vals.first.dst_adjust?
-      wrapper = TimeUtil::TimeWrapper.new(@time, dst_adjust)
-      wrapper.add(type, res.min)
-      wrapper.clear_below(type)
+      return unless (interval = res.min)
+      validation = vals.first
+      wrapper = TimeUtil::TimeWrapper.new(@time, validation.dst_adjust?)
+      wrapper.add(validation.type, interval)
+      wrapper.clear_below(validation.type)
 
       # Move over DST if blocked, no adjustments
       if wrapper.to_time <= @time

data/lib/ice_cube/validations/count.rb

@@ -29,6 +29,10 @@ module IceCube
         :limit
       end
 
+      def dst_adjust?
+        false
+      end
+
       def validate(time, schedule)
         raise CountExceeded if rule.uses && rule.uses >= count
       end

data/lib/ice_cube/validations/daily_interval.rb

@@ -22,6 +22,10 @@ module IceCube
         :day
       end
 
+      def dst_adjust?
+        true
+      end
+
       def validate(step_time, schedule)
         t0, t1 = schedule.start_time, step_time
         days = Date.new(t1.year, t1.month, t1.day) -

data/lib/ice_cube/validations/day.rb

@@ -31,6 +31,10 @@ module IceCube
         :wday
       end
 
+      def dst_adjust?
+        true
+      end
+
       def build_s(builder)
         builder.piece(:day) << day
       end

data/lib/ice_cube/validations/day_of_month.rb

@@ -28,6 +28,10 @@ module IceCube
         :day
       end
 
+      def dst_adjust?
+        true
+      end
+
       def build_s(builder)
         builder.piece(:day_of_month) << StringBuilder.nice_number(day)
       end

data/lib/ice_cube/validations/day_of_week.rb

@@ -26,6 +26,10 @@ module IceCube
         :day
       end
 
+      def dst_adjust?
+        true
+      end
+
       def validate(step_time, schedule)
         wday = step_time.wday
         offset = (day < wday) ? (7 - wday + day) : (day - wday)

data/lib/ice_cube/validations/day_of_year.rb

@@ -25,6 +25,10 @@ module IceCube
         :day
       end
 
+      def dst_adjust?
+        true
+      end
+
       def validate(step_time, schedule)
         days_in_year = TimeUtil.days_in_year(step_time)
         yday = day < 0 ? day + days_in_year : day

data/lib/ice_cube/validations/hour_of_day.rb

@@ -29,6 +29,10 @@ module IceCube
         :hour
       end
 
+      def dst_adjust?
+        true
+      end
+
       def build_s(builder)
         builder.piece(:hour_of_day) << StringBuilder.nice_number(hour)
       end

data/lib/ice_cube/validations/minute_of_hour.rb

@@ -28,6 +28,10 @@ module IceCube
         :min
       end
 
+      def dst_adjust?
+        false
+      end
+
       def build_s(builder)
         builder.piece(:minute_of_hour) << StringBuilder.nice_number(minute)
       end

data/lib/ice_cube/validations/month_of_year.rb

@@ -29,6 +29,10 @@ module IceCube
         :month
       end
 
+      def dst_adjust?
+        true
+      end
+
       def build_s(builder)
         builder.piece(:month_of_year) << Date::MONTHNAMES[month]
       end

data/lib/ice_cube/validations/monthly_interval.rb

@@ -21,6 +21,10 @@ module IceCube
         :month
       end
 
+      def dst_adjust?
+        true
+      end
+
       def validate(step_time, schedule)
         t0, t1 = schedule.start_time, step_time
         months = (t1.month - t0.month) +

data/lib/ice_cube/validations/second_of_minute.rb

@@ -28,6 +28,10 @@ module IceCube
         :sec
       end
 
+      def dst_adjust?
+        false
+      end
+
       def build_s(builder)
         builder.piece(:second_of_minute) << StringBuilder.nice_number(second)
       end

data/lib/ice_cube/validations/until.rb

@@ -29,6 +29,10 @@ module IceCube
         :limit
       end
 
+      def dst_adjust?
+        false
+      end
+
       def validate(step_time, schedule)
         raise UntilExceeded if step_time > time
       end

data/lib/ice_cube/validations/weekly_interval.rb

@@ -29,6 +29,10 @@ module IceCube
         :day
       end
 
+      def dst_adjust?
+        true
+      end
+
       def validate(step_time, schedule)
         t0, t1 = schedule.start_time, step_time
         d0 = Date.new(t0.year, t0.month, t0.day)

data/lib/ice_cube/validations/yearly_interval.rb

@@ -20,6 +20,10 @@ module IceCube
         :year
       end
 
+      def dst_adjust?
+        true
+      end
+
       def validate(step_time, schedule)
         years = step_time.year - schedule.start_time.year
         offset = (years % interval).nonzero?

data/lib/ice_cube/version.rb

@@ -1,5 +1,5 @@
 module IceCube
 
-  VERSION = '0.11.3'
+  VERSION = '0.12.0'
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ice_cube
 version: !ruby/object:Gem::Version
-  version: 0.11.3
+  version: 0.12.0
 platform: ruby
 authors:
 - John Crepezzi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-07 00:00:00.000000000 Z
+date: 2014-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -78,10 +78,15 @@ files:
 - lib/ice_cube/builders/ical_builder.rb
 - lib/ice_cube/builders/string_builder.rb
 - lib/ice_cube/deprecated.rb
+- lib/ice_cube/enumerator.rb
 - lib/ice_cube/errors/count_exceeded.rb
 - lib/ice_cube/errors/until_exceeded.rb
 - lib/ice_cube/flexible_hash.rb
+- lib/ice_cube/formatters/string.rb
+- lib/ice_cube/hash_input.rb
 - lib/ice_cube/occurrence.rb
+- lib/ice_cube/parsers/hash_parser.rb
+- lib/ice_cube/parsers/yaml_parser.rb
 - lib/ice_cube/rule.rb
 - lib/ice_cube/rules/daily_rule.rb
 - lib/ice_cube/rules/hourly_rule.rb
@@ -92,6 +97,8 @@ files:
 - lib/ice_cube/rules/yearly_rule.rb
 - lib/ice_cube/schedule.rb
 - lib/ice_cube/single_occurrence_rule.rb
+- lib/ice_cube/string_helpers.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
@@ -135,9 +142,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: ice-cube
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Ruby Date Recurrence Library
 test_files:
 - spec/spec_helper.rb
+has_rdoc: true