ice_cube 0.16.4 → 0.17.0

data/lib/ice_cube/parsers/ical_parser.rb

@@ -3,22 +3,22 @@ module IceCube
     def self.schedule_from_ical(ical_string, options = {})
       data = {}
       ical_string.each_line do |line|
-        (property, value) = line.split(':')
-        (property, _tzid) = property.split(';')
+        (property, value) = line.split(":")
+        (property, _tzid) = property.split(";")
         case property
-        when 'DTSTART'
+        when "DTSTART"
           data[:start_time] = TimeUtil.deserialize_time(value)
-        when 'DTEND'
+        when "DTEND"
           data[:end_time] = TimeUtil.deserialize_time(value)
-        when 'RDATE'
+        when "RDATE"
           data[:rtimes] ||= []
-          data[:rtimes] += value.split(',').map { |v| TimeUtil.deserialize_time(v) }
-        when 'EXDATE'
+          data[:rtimes] += value.split(",").map { |v| TimeUtil.deserialize_time(v) }
+        when "EXDATE"
           data[:extimes] ||= []
-          data[:extimes] += value.split(',').map { |v| TimeUtil.deserialize_time(v) }
-        when 'DURATION'
+          data[:extimes] += value.split(",").map { |v| TimeUtil.deserialize_time(v) }
+        when "DURATION"
           data[:duration] # FIXME
-        when 'RRULE'
+        when "RRULE"
           data[:rrules] ||= []
           data[:rrules] += [rule_from_ical(value)]
         end
@@ -27,54 +27,55 @@ module IceCube
     end
 
     def self.rule_from_ical(ical)
-      raise ArgumentError, 'empty ical rule' if ical.nil?
+      raise ArgumentError, "empty ical rule" if ical.nil?
 
       validations = {}
       params = {validations: validations, interval: 1}
 
-      ical.split(';').each do |rule|
-        (name, value) = rule.split('=')
+      ical.split(";").each do |rule|
+        (name, value) = rule.split("=")
         raise ArgumentError, "Invalid iCal rule component" if value.nil?
         value.strip!
         case name
-        when 'FREQ'
-          params[:rule_type] = "IceCube::#{value[0]}#{value.downcase[1..-1]}Rule"
-        when 'INTERVAL'
+        when "FREQ"
+          params[:rule_type] = "IceCube::#{value[0]}#{value.downcase[1..]}Rule"
+        when "INTERVAL"
           params[:interval] = value.to_i
-        when 'COUNT'
+        when "COUNT"
           params[:count] = value.to_i
-        when 'UNTIL'
+        when "UNTIL"
           params[:until] = TimeUtil.deserialize_time(value).utc
-        when 'WKST'
+        when "WKST"
           params[:week_start] = TimeUtil.ical_day_to_symbol(value)
-        when 'BYSECOND'
-          validations[:second_of_minute] = value.split(',').map(&:to_i)
-        when 'BYMINUTE'
-          validations[:minute_of_hour] = value.split(',').map(&:to_i)
-        when 'BYHOUR'
-          validations[:hour_of_day] = value.split(',').map(&:to_i)
-        when 'BYDAY'
+        when "BYSECOND"
+          validations[:second_of_minute] = value.split(",").map(&:to_i)
+        when "BYMINUTE"
+          validations[:minute_of_hour] = value.split(",").map(&:to_i)
+        when "BYHOUR"
+          validations[:hour_of_day] = value.split(",").map(&: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
+          value.split(",").each do |expr|
+            day = TimeUtil.ical_day_to_symbol(expr.strip[-2..])
+            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?
+            elsif dows[day].nil?
+              days.push TimeUtil.sym_to_wday(day)
             end
           end
           validations[:day_of_week] = dows unless dows.empty?
           validations[:day] = days unless days.empty?
-        when 'BYMONTHDAY'
-          validations[:day_of_month] = value.split(',').map(&:to_i)
-        when 'BYMONTH'
-          validations[:month_of_year] = value.split(',').map(&:to_i)
-        when 'BYYEARDAY'
-          validations[:day_of_year] = value.split(',').map(&:to_i)
-        when 'BYSETPOS'
+        when "BYMONTHDAY"
+          validations[:day_of_month] = value.split(",").map(&:to_i)
+        when "BYMONTH"
+          validations[:month_of_year] = value.split(",").map(&:to_i)
+        when "BYYEARDAY"
+          validations[:day_of_year] = value.split(",").map(&:to_i)
+        when "BYSETPOS"
+          # noop
         else
           validations[name] = nil # invalid type
         end

data/lib/ice_cube/parsers/yaml_parser.rb

@@ -1,19 +1,17 @@
-require 'yaml'
+require "yaml"
 
 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)
+      @hash = YAML.safe_load(yaml, permitted_classes: [Date, Symbol, Time], aliases: true)
       yaml.match SERIALIZED_START do |match|
         start_time = hash[:start_time] || hash[:start_date]
         TimeUtil.restore_deserialized_offset start_time, match[:tz]
       end
     end
-
   end
 end

data/lib/ice_cube/rule.rb

@@ -1,9 +1,7 @@
-require 'yaml'
+require "yaml"
 
 module IceCube
-
   class Rule
-
     INTERVAL_TYPES = [
       :secondly, :minutely, :hourly,
       :daily, :weekly, :monthly, :yearly
@@ -39,12 +37,12 @@ module IceCube
 
     # Yaml implementation
     def to_yaml(*args)
-      YAML::dump(to_hash, *args)
+      YAML.dump(to_hash, *args)
     end
 
     # From yaml
     def self.from_yaml(yaml)
-      from_hash YAML::load(yaml)
+      from_hash YAML.safe_load(yaml, permitted_classes: [Date, Symbol, Time])
     end
 
     def to_hash
@@ -59,13 +57,12 @@ module IceCube
     end
 
     class << self
-
       # Convert from a hash and create a rule
       def from_hash(original_hash)
         hash = IceCube::FlexibleHash.new original_hash
 
-        unless hash[:rule_type] && match = hash[:rule_type].match(/\:\:(.+?)Rule/)
-          raise ArgumentError, 'Invalid rule type'
+        unless hash[:rule_type] && (match = hash[:rule_type].match(/::(.+?)Rule/))
+          raise ArgumentError, "Invalid rule type"
         end
 
         interval_type = match[1].downcase.to_sym
@@ -76,14 +73,11 @@ module IceCube
 
         rule = IceCube::Rule.send(interval_type, hash[:interval] || 1)
 
-        if match[1] == "Weekly"
-          rule.interval(hash[:interval] || 1, TimeUtil.wday_to_sym(hash[:week_start] || 0))
-        end
-
+        rule.interval(hash[:interval] || 1, TimeUtil.wday_to_sym(hash[:week_start] || 0)) if rule.is_a? WeeklyRule
         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|
+        hash[:validations]&.each do |name, args|
           apply_validation(rule, name, args)
         end
 
@@ -101,12 +95,10 @@ module IceCube
 
         args.is_a?(Array) ? rule.send(name, *args) : rule.send(name, args)
       end
-
     end
 
     # Convenience methods for creating Rules
     class << self
-
       # Secondly Rule
       def secondly(interval = 1)
         SecondlyRule.new(interval)
@@ -141,9 +133,6 @@ module IceCube
       def yearly(interval = 1)
         YearlyRule.new(interval)
       end
-
     end
-
   end
-
 end

data/lib/ice_cube/rules/daily_rule.rb

@@ -1,7 +1,5 @@
 module IceCube
-
   class DailyRule < ValidatedRule
-
     include Validations::HourOfDay
     include Validations::MinuteOfHour
     include Validations::SecondOfMinute
@@ -19,7 +17,5 @@ module IceCube
       schedule_lock(:hour, :min, :sec)
       reset
     end
-
   end
-
 end

data/lib/ice_cube/rules/hourly_rule.rb

@@ -1,7 +1,5 @@
 module IceCube
-
   class HourlyRule < ValidatedRule
-
     include Validations::HourOfDay
     include Validations::MinuteOfHour
     include Validations::SecondOfMinute
@@ -19,7 +17,5 @@ module IceCube
       schedule_lock(:min, :sec)
       reset
     end
-
   end
-
 end

data/lib/ice_cube/rules/minutely_rule.rb

@@ -1,7 +1,5 @@
 module IceCube
-
   class MinutelyRule < ValidatedRule
-
     include Validations::HourOfDay
     include Validations::MinuteOfHour
     include Validations::SecondOfMinute
@@ -19,7 +17,5 @@ module IceCube
       schedule_lock(:sec)
       reset
     end
-
   end
-
 end

data/lib/ice_cube/rules/monthly_rule.rb

@@ -1,7 +1,5 @@
 module IceCube
-
   class MonthlyRule < ValidatedRule
-
     include Validations::HourOfDay
     include Validations::MinuteOfHour
     include Validations::SecondOfMinute
@@ -19,7 +17,5 @@ module IceCube
       schedule_lock(:day, :hour, :min, :sec)
       reset
     end
-
   end
-
 end

data/lib/ice_cube/rules/secondly_rule.rb

@@ -1,7 +1,5 @@
 module IceCube
-
   class SecondlyRule < ValidatedRule
-
     include Validations::HourOfDay
     include Validations::MinuteOfHour
     include Validations::SecondOfMinute
@@ -18,7 +16,5 @@ module IceCube
       interval(interval)
       reset
     end
-
   end
-
 end

data/lib/ice_cube/rules/weekly_rule.rb

@@ -1,7 +1,5 @@
 module IceCube
-
   class WeeklyRule < ValidatedRule
-
     include Validations::HourOfDay
     include Validations::MinuteOfHour
     include Validations::SecondOfMinute
@@ -37,7 +35,7 @@ module IceCube
       time = TimeUtil::TimeWrapper.new(start_time)
       offset = wday_offset(step_time, start_time)
       time.add(:day, offset)
-      super step_time, time.to_time
+      super(step_time, time.to_time)
     end
 
     # Calculate how many days to the first wday validation in the correct
@@ -57,7 +55,5 @@ module IceCube
 
       days + interval - step_wday + min_wday
     end
-
   end
-
 end

data/lib/ice_cube/rules/yearly_rule.rb

@@ -1,7 +1,5 @@
 module IceCube
-
   class YearlyRule < ValidatedRule
-
     include Validations::HourOfDay
     include Validations::MinuteOfHour
     include Validations::SecondOfMinute
@@ -19,7 +17,5 @@ module IceCube
       schedule_lock(:month, :day, :hour, :min, :sec)
       reset
     end
-
   end
-
 end

data/lib/ice_cube/schedule.rb

@@ -1,9 +1,7 @@
-require 'yaml'
+require "yaml"
 
 module IceCube
-
   class Schedule
-
     extend Deprecated
 
     # Get the start time
@@ -51,7 +49,7 @@ module IceCube
       add_recurrence_rule rule
       time
     end
-    alias :rtime :add_recurrence_time
+    alias_method :rtime, :add_recurrence_time
     deprecated_alias :rdate, :rtime
     deprecated_alias :add_recurrence_date, :add_recurrence_time
 
@@ -62,7 +60,7 @@ module IceCube
       add_exception_rule rule
       time
     end
-    alias :extime :add_exception_time
+    alias_method :extime, :add_exception_time
     deprecated_alias :exdate, :extime
     deprecated_alias :add_exception_date, :add_exception_time
 
@@ -71,7 +69,7 @@ module IceCube
       return if rule.nil?
       @all_recurrence_rules << rule unless @all_recurrence_rules.include?(rule)
     end
-    alias :rrule :add_recurrence_rule
+    alias_method :rrule, :add_recurrence_rule
 
     # Remove a recurrence rule
     def remove_recurrence_rule(rule)
@@ -84,7 +82,7 @@ module IceCube
       return if rule.nil?
       @all_exception_rules << rule unless @all_exception_rules.include?(rule)
     end
-    alias :exrule :add_exception_rule
+    alias_method :exrule, :add_exception_rule
 
     # Remove an exception rule
     def remove_exception_rule(rule)
@@ -96,19 +94,19 @@ module IceCube
     def recurrence_rules
       @all_recurrence_rules.reject { |r| r.is_a?(SingleOccurrenceRule) }
     end
-    alias :rrules :recurrence_rules
+    alias_method :rrules, :recurrence_rules
 
     # Get the exception rules
     def exception_rules
       @all_exception_rules.reject { |r| r.is_a?(SingleOccurrenceRule) }
     end
-    alias :exrules :exception_rules
+    alias_method :exrules, :exception_rules
 
     # Get the recurrence times that are on the schedule
     def recurrence_times
       @all_recurrence_rules.select { |r| r.is_a?(SingleOccurrenceRule) }.map(&:time)
     end
-    alias :rtimes :recurrence_times
+    alias_method :rtimes, :recurrence_times
     deprecated_alias :rdates, :rtimes
     deprecated_alias :recurrence_dates, :recurrence_times
 
@@ -120,7 +118,7 @@ module IceCube
       end
       time if found
     end
-    alias :remove_rtime :remove_recurrence_time
+    alias_method :remove_rtime, :remove_recurrence_time
     deprecated_alias :remove_recurrence_date, :remove_recurrence_time
     deprecated_alias :remove_rdate, :remove_rtime
 
@@ -128,7 +126,7 @@ module IceCube
     def exception_times
       @all_exception_rules.select { |r| r.is_a?(SingleOccurrenceRule) }.map(&:time)
     end
-    alias :extimes :exception_times
+    alias_method :extimes, :exception_times
     deprecated_alias :exdates, :extimes
     deprecated_alias :exception_dates, :exception_times
 
@@ -140,7 +138,7 @@ module IceCube
       end
       time if found
     end
-    alias :remove_extime :remove_exception_time
+    alias_method :remove_extime, :remove_exception_time
     deprecated_alias :remove_exception_date, :remove_exception_time
     deprecated_alias :remove_exdate, :remove_extime
 
@@ -162,8 +160,8 @@ module IceCube
     end
 
     # Iterate forever
-    def each_occurrence(&block)
-      enumerate_occurrences(start_time, &block).to_a
+    def each_occurrence(&)
+      enumerate_occurrences(start_time, &).to_a
       self
     end
 
@@ -193,7 +191,7 @@ module IceCube
       from = TimeUtil.match_zone(from, start_time) or raise ArgumentError, "Time required, got #{from.inspect}"
       return [] if from <= start_time
       a = enumerate_occurrences(start_time, from - 1).to_a
-      a.size > num ? a[-1*num,a.size] : a
+      (a.size > num) ? a[-1 * num, a.size] : a
     end
 
     # The remaining occurrences (same requirements as all_occurrences)
@@ -228,7 +226,7 @@ module IceCube
     # occurrences at the end of the range since none of their duration
     # intersects the range.
     def occurring_between?(opening_time, closing_time)
-      occurs_between?(opening_time, closing_time, :spans => true)
+      occurs_between?(opening_time, closing_time, spans: true)
     end
 
     # Return a boolean indicating if an occurrence falls on a certain date
@@ -306,7 +304,7 @@ module IceCube
     def last(n = nil)
       require_terminating_rules
       occurrences = enumerate_occurrences(start_time).to_a
-      n.nil? ? occurrences.last : occurrences[-n..-1]
+      n.nil? ? occurrences.last : occurrences[-n..]
     end
 
     # String serialization
@@ -314,13 +312,13 @@ module IceCube
       pieces = []
       rd = recurrence_times_with_start_time - extimes
       pieces.concat rd.sort.map { |t| IceCube::I18n.l(t, format: IceCube.to_s_time_format) }
-      pieces.concat rrules.map  { |t| t.to_s }
-      pieces.concat exrules.map { |t| IceCube::I18n.t('ice_cube.not', target: t.to_s) }
+      pieces.concat rrules.map { |t| t.to_s }
+      pieces.concat exrules.map { |t| IceCube::I18n.t("ice_cube.not", target: t.to_s) }
       pieces.concat extimes.sort.map { |t|
         target = IceCube::I18n.l(t, format: IceCube.to_s_time_format)
-        IceCube::I18n.t('ice_cube.not_on', target: target)
+        IceCube::I18n.t("ice_cube.not_on", target: target)
       }
-      pieces.join(IceCube::I18n.t('ice_cube.pieces_connector'))
+      pieces.join(IceCube::I18n.t("ice_cube.pieces_connector"))
     end
 
     # Serialize this schedule to_ical
@@ -328,9 +326,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 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.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
@@ -360,9 +358,7 @@ module IceCube
       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)
-      if IceCube.compatibility <= 11 && exception_rules.any?
-        data[:exrules] = exception_rules.map(&:to_hash)
-      end
+      data[:exrules] = exception_rules.map(&:to_hash) if exception_rules.any?
       data[:rtimes] = recurrence_times.map do |rt|
         TimeUtil.serialize_time(rt)
       end
@@ -396,9 +392,9 @@ module IceCube
     end
 
     def eql?(other)
-      self.hash == other.hash
+      hash == other.hash
     end
-    alias == eql?
+    alias_method :==, :eql?
 
     def self.dump(schedule)
       return schedule if schedule.nil? || schedule == ""
@@ -435,7 +431,7 @@ module IceCube
         loop do
           break unless (t0 = next_time(t1, closing_time))
           break if closing_time && t0 > closing_time
-          if (spans ? (t0.end_time > opening_time) : (t0 >= opening_time))
+          if spans ? (t0.end_time > opening_time) : (t0 >= opening_time)
             yielder << (block_given? ? yield(t0) : t0)
           end
           t1 = t0 + 1
@@ -447,12 +443,10 @@ module IceCube
     def next_time(time, closing_time)
       loop do
         min_time = recurrence_rules_with_implicit_start_occurrence.reduce(nil) do |best_time, rule|
-          begin
-            new_time = rule.next_time(time, start_time, best_time || closing_time)
-            [best_time, new_time].compact.min
-          rescue StopIteration
-            best_time
-          end
+          new_time = rule.next_time(time, start_time, best_time || closing_time)
+          [best_time, new_time].compact.min
+        rescue StopIteration
+          best_time
         end
         break unless min_time
         next (time = min_time + 1) if exception_time?(min_time)
@@ -464,7 +458,7 @@ module IceCube
     # 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?)
+        @all_exception_rules.any?(&:full_required?)
     end
 
     # Return a boolean indicating whether or not a specific time
@@ -477,7 +471,7 @@ module IceCube
 
     def require_terminating_rules
       return true if terminating?
-      method_name = caller[0].split(' ').last
+      method_name = caller(1..1).first.split(" ").last
       raise ArgumentError, "All recurrence rules must specify .until or .count to use #{method_name}"
     end
 
@@ -504,7 +498,5 @@ module IceCube
         @all_recurrence_rules
       end
     end
-
   end
-
 end

data/lib/ice_cube/single_occurrence_rule.rb

@@ -1,7 +1,5 @@
 module IceCube
-
   class SingleOccurrenceRule < Rule
-
     attr_reader :time
 
     def initialize(time)
@@ -20,13 +18,11 @@ module IceCube
     end
 
     def to_hash
-      { :time => time }
+      {time: time}
     end
 
     def full_required?
       false
     end
-
   end
-
 end