ice_cube 0.12.1 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2ac4ca18d263a59f5e9499349ce536e63d8ec59f
-  data.tar.gz: 3d2d4ed0d0cf8c0632b870b19e59ac964d64f93a
+  metadata.gz: 9b2874169ce6feed9740297977d1dc7a4de82c83
+  data.tar.gz: 6b7c7b5c35167429740adb2f64eced33413b3e93
 SHA512:
-  metadata.gz: d6715a91023b1c7c0fa7f1bdc59776c0182b3742bd37a6fc28fd14e0bd15ee5e4d0e2c1014c03c43c04cfaaee8b73ed19d5a7557b815f949fe72d044fb9a61bb
-  data.tar.gz: f2941f23021a8062fc35cc3f3dd1bd2010903645d723aa9bf7ba3b50a4c240ef88757539c6317b4cab967f7d357a5ccf915d84c963659a97a54d47f5c05efc53
+  metadata.gz: 7d9ec04b5840a45acd23ad7f41e44491ff6cb66f85348d32504ec3116955513eb2e4ec3c8e6281c958d2f6957ec7f08ff67e126a4853618fa748da84d5705638
+  data.tar.gz: e47242b8441a7eb029ebd4c128030eb004110d539aed236ad1b55a8c02f378483fdf925c93ccbf4c794dd990d6a5b80bd3f9a1728c4d5c6e8f748c3a1f33cce8

data/lib/ice_cube.rb

@@ -18,6 +18,7 @@ module IceCube
 
   autoload :HashParser, 'ice_cube/parsers/hash_parser'
   autoload :YamlParser, 'ice_cube/parsers/yaml_parser'
+  autoload :IcalParser, 'ice_cube/parsers/ical_parser'
 
   autoload :CountExceeded, 'ice_cube/errors/count_exceeded'
   autoload :UntilExceeded, 'ice_cube/errors/until_exceeded'
@@ -34,8 +35,7 @@ module IceCube
   autoload :YearlyRule, 'ice_cube/rules/yearly_rule'
 
   module Validations
-
-    autoload :Lock, 'ice_cube/validations/lock'
+    autoload :FixedValue, 'ice_cube/validations/fixed_value'
     autoload :ScheduleLock, 'ice_cube/validations/schedule_lock'
 
     autoload :Count, 'ice_cube/validations/count'

data/lib/ice_cube/occurrence.rb

@@ -84,7 +84,7 @@ module IceCube
     # time formats and is only used when ActiveSupport is available.
     #
     def to_s(format=nil)
-      if format && to_time.public_method(:to_s).arity > 0
+      if format && to_time.public_method(:to_s).arity != 0
         t0, t1 = start_time.to_s(format), end_time.to_s(format)
       else
         t0, t1 = start_time.to_s, end_time.to_s

data/lib/ice_cube/parsers/hash_parser.rb

@@ -53,7 +53,9 @@ module IceCube
     def apply_rrules(schedule, data)
       return unless data[:rrules]
       data[:rrules].each do |h|
-        schedule.rrule(IceCube::Rule.from_hash(h))
+        rrule = h.is_a?(IceCube::Rule) ? h : IceCube::Rule.from_hash(h)
+
+        schedule.rrule(rrule)
       end
     end
 
@@ -61,7 +63,9 @@ module IceCube
       return unless data[:exrules]
       warn "IceCube: :exrules is deprecated, and will be removed in a future release. at: #{ caller[0] }"
       data[:exrules].each do |h|
-        schedule.exrule(IceCube::Rule.from_hash(h))
+        rrule = h.is_a?(IceCube::Rule) ? h : IceCube::Rule.from_hash(h)
+
+        schedule.exrule(rrule)
       end
     end
 

data/lib/ice_cube/parsers/ical_parser.rb

@@ -0,0 +1,90 @@
+module IceCube
+  class IcalParser
+    def self.schedule_from_ical(ical_string, options = {})
+      data = {}
+      ical_string.each_line do |line|
+        (property, value) = line.split(':')
+        (property, tzid) = property.split(';')
+        case property
+        when 'DTSTART'
+          data[:start_time] = Time.parse(value)
+        when 'DTEND'
+          data[:end_time] = Time.parse(value)
+        when 'EXDATE'
+          data[:extimes] ||= []
+          data[:extimes] += value.split(',').map{|v| Time.parse(v)}
+        when 'DURATION'
+          data[:duration] # FIXME
+        when 'RRULE'
+          data[:rrules] = [rule_from_ical(value)]
+        end
+      end
+      Schedule.from_hash data
+    end
+
+    def self.rule_from_ical(ical)
+      params = { validations: { } }
+
+      ical.split(';').each do |rule|
+        (name, value) = rule.split('=')
+        value.strip!
+        case name
+        when 'FREQ'
+          params[:freq] = value.downcase
+        when 'INTERVAL'
+          params[:interval] = value.to_i
+        when 'COUNT'
+          params[:count] = value.to_i
+        when 'UNTIL'
+          params[:until] = Time.parse(value).utc
+        when 'WKST'
+          params[:wkst] = TimeUtil.ical_day_to_symbol(value)
+        when 'BYSECOND'
+          params[:validations][:second_of_minute] = value.split(',').collect(&:to_i)
+        when 'BYMINUTE'
+          params[:validations][:minute_of_hour] = value.split(',').collect(&:to_i)
+        when 'BYHOUR'
+          params[:validations][:hour_of_day] = value.split(',').collect(&:to_i)
+        when 'BYDAY'
+          dows = {}
+          days = []
+          value.split(',').each do |expr|
+            day = TimeUtil.ical_day_to_symbol(expr.strip[-2..-1])
+            if expr.strip.length > 2  # day with occurence
+              occ = expr[0..-3].to_i
+              dows[day].nil? ? dows[day] = [occ] : dows[day].push(occ)
+              days.delete(TimeUtil.sym_to_wday(day))
+            else
+              days.push TimeUtil.sym_to_wday(day) if dows[day].nil?
+            end
+          end
+          params[:validations][:day_of_week] = dows unless dows.empty?
+          params[:validations][:day] = days unless days.empty?
+        when 'BYMONTHDAY'
+          params[:validations][:day_of_month] = value.split(',').collect(&:to_i)
+        when 'BYMONTH'
+          params[:validations][:month_of_year] = value.split(',').collect(&:to_i)
+        when 'BYYEARDAY'
+          params[:validations][:day_of_year] = value.split(',').collect(&:to_i)
+        when 'BYSETPOS'
+        else
+          raise "Invalid or unsupported rrule command: #{name}"
+        end
+      end
+
+      params[:interval] ||= 1
+
+      # WKST only valid for weekly rules
+      params.delete(:wkst) unless params[:freq] == 'weekly'
+
+      rule = Rule.send(*params.values_at(:freq, :interval, :wkst).compact)
+      rule.count(params[:count]) if params[:count]
+      rule.until(params[:until]) if params[:until]
+      params[:validations].each do |key, value|
+        value.is_a?(Array) ? rule.send(key, *value) : rule.send(key, value)
+      end
+
+      rule
+    end
+  end
+end

data/lib/ice_cube/rule.rb

@@ -27,6 +27,11 @@ module IceCube
       raise MethodNotImplemented, "Expected to be overrridden by subclasses"
     end
 
+    # Convert from ical string and create a rule
+    def self.from_ical(ical)
+      IceCube::IcalParser.rule_from_ical(ical)
+    end
+
     # Yaml implementation
     def to_yaml(*args)
       YAML::dump(to_hash, *args)

data/lib/ice_cube/schedule.rb

@@ -167,28 +167,28 @@ module IceCube
 
     # The next n occurrences after now
     def next_occurrences(num, from = nil)
-      from ||= TimeUtil.now(@start_time)
+      from = TimeUtil.match_zone(from, start_time) || TimeUtil.now(start_time)
       enumerate_occurrences(from + 1, nil).take(num)
     end
 
     # The next occurrence after now (overridable)
     def next_occurrence(from = nil)
-      from ||= TimeUtil.now(@start_time)
-      begin
-        enumerate_occurrences(from + 1, nil).next()
-      rescue StopIteration
-        nil
-      end
+      from = TimeUtil.match_zone(from, start_time) || TimeUtil.now(start_time)
+      enumerate_occurrences(from + 1, nil).next
+    rescue StopIteration
+      nil
     end
 
     # The previous occurrence from a given time
     def previous_occurrence(from)
+      from = TimeUtil.match_zone(from, start_time) or raise ArgumentError, "Time required, got #{time.inspect}"
       return nil if from <= start_time
       enumerate_occurrences(start_time, from - 1).to_a.last
     end
 
     # The previous n occurrences before a given time
     def previous_occurrences(num, from)
+      from = TimeUtil.match_zone(from, start_time) or raise ArgumentError, "Time required, got #{time.inspect}"
       return [] if from <= start_time
       a = enumerate_occurrences(start_time, from - 1).to_a
       a.size > num ? a[-1*num,a.size] : a
@@ -214,12 +214,10 @@ module IceCube
 
     # Return a boolean indicating if an occurrence falls between two times
     def occurs_between?(begin_time, closing_time)
-      begin
-        enumerate_occurrences(begin_time, closing_time).next()
-        true
-      rescue StopIteration
-        false
-      end
+      enumerate_occurrences(begin_time, closing_time).next
+      true
+    rescue StopIteration
+      false
     end
 
     # Return a boolean indicating if an occurrence is occurring between two
@@ -235,7 +233,7 @@ module IceCube
 
     # Return a boolean indicating if an occurrence falls on a certain date
     def occurs_on?(date)
-      date = TimeUtil.ensure_date date
+      date = TimeUtil.ensure_date(date)
       begin_time = TimeUtil.beginning_of_date(date, start_time)
       closing_time = TimeUtil.end_of_date(date, start_time)
       occurs_between?(begin_time, closing_time)
@@ -243,6 +241,7 @@ module IceCube
 
     # Determine if the schedule is occurring at a given time
     def occurring_at?(time)
+      time = TimeUtil.match_zone(time, start_time) or raise ArgumentError, "Time required, got #{time.inspect}"
       if duration > 0
         return false if exception_time?(time)
         occurs_between?(time - duration + 1, time)
@@ -256,7 +255,7 @@ module IceCube
     # @param [Time] closing_time - the last time to consider
     # @return [Boolean] whether or not the schedules conflict at all
     def conflicts_with?(other_schedule, closing_time = nil)
-      closing_time = TimeUtil.ensure_time closing_time
+      closing_time = TimeUtil.ensure_time(closing_time)
       unless terminating? || other_schedule.terminating? || closing_time
         raise ArgumentError, "One or both schedules must be terminating to use #conflicts_with?"
       end
@@ -333,6 +332,11 @@ module IceCube
       pieces.join("\n")
     end
 
+    # Load the schedule from ical
+    def self.from_ical(ical, options = {})
+      IcalParser.schedule_from_ical(ical, options)
+    end
+
     # Convert the schedule to yaml
     def to_yaml(*args)
       YAML::dump(to_hash, *args)
@@ -404,10 +408,10 @@ module IceCube
       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
-      t1 = full_required? ? start_time : opening_time
-      e = Enumerator.new do |yielder|
+      Enumerator.new do |yielder|
+        reset
+        t1 = full_required? ? start_time : realign(opening_time)
         loop do
           break unless (t0 = next_time(t1, closing_time))
           break if closing_time && t0 > closing_time
@@ -492,6 +496,28 @@ 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/time_util.rb

@@ -11,6 +11,11 @@ module IceCube
       :thursday => 4, :friday => 5, :saturday => 6
     }
 
+    ICAL_DAYS = {
+      'SU' => :sunday, 'MO' => :monday, 'TU' => :tuesday, 'WE' => :wednesday,
+      'TH' => :thursday, 'FR' => :friday, 'SA' => :saturday
+    }
+
     MONTHS = {
       :january => 1, :february => 2, :march => 3, :april => 4, :may => 5,
       :june => 6, :july => 7, :august => 8, :september => 9, :october => 10,
@@ -24,21 +29,34 @@ module IceCube
       match_zone(Time.at(Time.now.to_i), reference)
     end
 
-    def self.match_zone(time, reference)
-      return unless time = ensure_time(time)
-      if reference.respond_to? :time_zone
-        time.in_time_zone(reference.time_zone)
+    def self.build_in_zone(args, reference)
+      if reference.respond_to?(:time_zone)
+        reference.time_zone.local(*args)
+      elsif reference.utc?
+        Time.utc(*args)
+      elsif reference.zone
+        Time.local(*args)
       else
-        if reference.utc?
-          time.utc
-        elsif reference.zone
-          time.getlocal
-        else
-          time.getlocal(reference.utc_offset)
-        end
+        Time.new(*args << reference.utc_offset)
       end
     end
 
+    def self.match_zone(input_time, reference)
+      return unless time = ensure_time(input_time)
+      time = if reference.respond_to? :time_zone
+               time.in_time_zone(reference.time_zone)
+             else
+               if reference.utc?
+                 time.utc
+               elsif reference.zone
+                 time.getlocal
+               else
+                 time.getlocal(reference.utc_offset)
+               end
+             end
+      (Date === input_time) ? beginning_of_date(time, reference) : time
+    end
+
     # Ensure that this is either nil, or a time
     def self.ensure_time(time, date_eod = false)
       case time
@@ -96,25 +114,13 @@ module IceCube
     end
 
     # Get the beginning of a date
-    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
-        match_zone(Time.new(*args << reference.utc_offset), reference)
-      end
+    def self.beginning_of_date(date, reference=Time.now)
+      build_in_zone([date.year, date.month, date.day, 0, 0, 0], reference)
     end
 
     # Get the end of a date
-    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
-        match_zone(Time.new(*args << reference.utc_offset), reference)
-      end
+    def self.end_of_date(date, reference=Time.now)
+      build_in_zone([date.year, date.month, date.day, 23, 59, 59], reference)
     end
 
     # Convert a symbol to a numeric month
@@ -146,12 +152,25 @@ module IceCube
       end
     end
 
+    # Convert a symbol to an ical day (SU, MO)
+    def self.week_start(sym)
+      raise ArgumentError, "Invalid day: #{str}" unless DAYS.keys.include?(sym)
+      day = sym.to_s.upcase[0..1]
+      day
+    end
+
     # Convert weekday from base sunday to the schedule's week start.
     def self.normalize_wday(wday, week_start)
       (wday - sym_to_wday(week_start)) % 7
     end
     deprecated_alias :normalize_weekday, :normalize_wday
 
+    def self.ical_day_to_symbol(str)
+      day = ICAL_DAYS[str]
+      raise ArgumentError, "Invalid day: #{str}" if day.nil?
+      day
+    end
+
     # Return the count of the number of times wday appears in the month,
     # and which of those time falls on
     def self.which_occurrence_in_month(time, wday)

data/lib/ice_cube/validated_rule.rb

@@ -30,10 +30,24 @@ module IceCube
       :interval
     ]
 
+    attr_reader :validations
+
     def initialize(interval = 1, *)
       @validations = Hash.new
     end
 
+    def base_interval_validation
+      @validations[:interval].first
+    end
+
+    def other_interval_validations
+      Array(@validations[base_interval_validation.type])
+    end
+
+    def base_interval_type
+      base_interval_validation.type
+    end
+
     # Compute the next time after (or including) the specified time in respect
     # to the given schedule
     def next_time(time, schedule, closing_time)
@@ -106,6 +120,7 @@ module IceCube
     end
 
     private
+
     def normalized_interval(interval)
       int = interval.to_i
       raise ArgumentError, "'#{interval}' is not a valid input for interval. Please pass an integer." unless int > 0
@@ -127,15 +142,11 @@ module IceCube
 
     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
-      if res.any? { |r| r.nil? || r == 0 }
-        true
-      else
-        return nil if res.all? { |r| r === true } # allow quick escaping
-        res.reject! { |r| r.nil? || r == 0 || r === true }
-        shift_time_by_validation(res, validations_for_type)
-        false
-      end
+      return true if res.any? { |r| r.nil? || r == 0 }
+      return nil if res.all? { |r| r == true }
+      res.reject! { |r| r == true }
+      shift_time_by_validation(res, validations_for_type.first)
+      false
     end
 
     def validated_results(validations_for_type)
@@ -144,9 +155,8 @@ module IceCube
       end
     end
 
-    def shift_time_by_validation(res, vals)
+    def shift_time_by_validation(res, validation)
       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)

data/lib/ice_cube/validations/day.rb

@@ -16,9 +16,7 @@ module IceCube
       self
     end
 
-    class Validation
-
-      include Validations::Lock
+    class Validation < Validations::FixedValue
 
       attr_reader :day
       alias :value :day

data/lib/ice_cube/validations/day_of_month.rb

@@ -13,9 +13,7 @@ module IceCube
       self
     end
 
-    class Validation
-
-      include Validations::Lock
+    class Validation < Validations::FixedValue
 
       attr_reader :day
       alias :value :day

data/lib/ice_cube/validations/fixed_value.rb

@@ -0,0 +1,95 @@
+module IceCube
+
+  # This abstract validation class is used by the various "fixed-time" (e.g.
+  # day, day_of_month, hour_of_day) Validation and ScheduleLock::Validation
+  # modules. It is not a standalone rule validation module like the others.
+  #
+  # Given the including Validation's defined +type+ field, it will lock to the
+  # specified +value+ or else the corresponding time unit from the schedule's
+  # start_time
+  #
+  class Validations::FixedValue
+
+    INTERVALS = {:min => 60, :sec => 60, :hour => 24, :month => 12, :wday => 7}
+
+    def validate(time, schedule)
+      case type
+      when :day  then validate_day_lock(time, schedule)
+      when :hour then validate_hour_lock(time, schedule)
+      else validate_interval_lock(time, schedule)
+      end
+    end
+
+    private
+
+    # 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)
+      t1 = time.send(type)
+      t0 >= t1 ? t0 - t1 : INTERVALS[type] - t1 + t0
+    end
+
+    # 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)
+      h1 = time.hour
+      if h0 >= h1
+        h0 - h1
+      else
+        if dst_offset = TimeUtil.dst_change(time)
+          h0 - h1 + dst_offset
+        else
+          24 - h1 + h0
+        end
+      end
+    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
+
+      sleeps = start - date.day
+
+      if value && value > 0
+        until_next_month = days_in_month + sleeps
+      else
+        until_next_month = start < 28 ? days_in_month : TimeUtil.days_to_next_month(date)
+        until_next_month += sleeps - month_overflow
+      end
+
+      sleeps >= 0 ? sleeps : until_next_month
+    end
+
+    def starting_unit(start_time)
+      start = value || start_time.send(type)
+      start = start % INTERVALS[type] if start < 0
+      start
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/hour_of_day.rb

@@ -14,9 +14,7 @@ module IceCube
       self
     end
 
-    class Validation
-
-      include Validations::Lock
+    class Validation < Validations::FixedValue
 
       attr_reader :hour
       alias :value :hour

data/lib/ice_cube/validations/minute_of_hour.rb

@@ -13,9 +13,7 @@ module IceCube
       self
     end
 
-    class Validation
-
-      include Validations::Lock
+    class Validation < Validations::FixedValue
 
       attr_reader :minute
       alias :value :minute

data/lib/ice_cube/validations/month_of_year.rb

@@ -14,9 +14,7 @@ module IceCube
       self
     end
 
-    class Validation
-
-      include Validations::Lock
+    class Validation < Validations::FixedValue
 
       attr_reader :month
       alias :value :month

data/lib/ice_cube/validations/schedule_lock.rb

@@ -12,9 +12,7 @@ module IceCube
       end
     end
 
-    class Validation
-
-      include Validations::Lock
+    class Validation < Validations::FixedValue
 
       attr_reader :type, :value
 

data/lib/ice_cube/validations/second_of_minute.rb

@@ -13,9 +13,7 @@ module IceCube
       self
     end
 
-    class Validation
-
-      include Validations::Lock
+    class Validation < Validations::FixedValue
 
       attr_reader :second
       alias :value :second

data/lib/ice_cube/validations/weekly_interval.rb

@@ -39,7 +39,7 @@ module IceCube
         d1 = Date.new(t1.year, t1.month, t1.day)
         days = (d1 - TimeUtil.normalize_wday(d1.wday, week_start)) -
                (d0 - TimeUtil.normalize_wday(d0.wday, week_start))
-        offset = ((days / 7) % interval).nonzero?
+        offset = ((days.to_i / 7) % interval).nonzero?
         (interval - offset) * 7 if offset
       end
 

data/lib/ice_cube/version.rb

@@ -1,5 +1,5 @@
 module IceCube
 
-  VERSION = '0.12.1'
+  VERSION = '0.13.0'
 
 end

data/spec/spec_helper.rb

@@ -7,6 +7,8 @@ end
 
 require File.dirname(__FILE__) + '/../lib/ice_cube'
 
+IceCube.compatibility = 12
+
 DAY = Time.utc(2010, 3, 1)
 WEDNESDAY = Time.utc(2010, 6, 23, 5, 0, 0)
 
@@ -17,6 +19,9 @@ WORLD_TIME_ZONES = [
 ]
 
 RSpec.configure do |config|
+  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
@@ -50,4 +55,10 @@ RSpec.configure do |config|
     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.12.1
+  version: 0.13.0
 platform: ruby
 authors:
 - John Crepezzi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-04 00:00:00.000000000 Z
+date: 2015-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -83,6 +83,7 @@ files:
 - lib/ice_cube/flexible_hash.rb
 - lib/ice_cube/occurrence.rb
 - lib/ice_cube/parsers/hash_parser.rb
+- lib/ice_cube/parsers/ical_parser.rb
 - lib/ice_cube/parsers/yaml_parser.rb
 - lib/ice_cube/rule.rb
 - lib/ice_cube/rules/daily_rule.rb
@@ -102,6 +103,7 @@ files:
 - lib/ice_cube/validations/day_of_month.rb
 - lib/ice_cube/validations/day_of_week.rb
 - lib/ice_cube/validations/day_of_year.rb
+- lib/ice_cube/validations/fixed_value.rb
 - lib/ice_cube/validations/hour_of_day.rb
 - lib/ice_cube/validations/hourly_interval.rb
 - lib/ice_cube/validations/lock.rb
@@ -137,7 +139,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: ice-cube
-rubygems_version: 2.2.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Ruby Date Recurrence Library