ice_cube 0.16.3 → 0.17.0

data/lib/ice_cube/flexible_hash.rb

@@ -1,13 +1,11 @@
-require 'delegate'
+require "delegate"
 
 module IceCube
-
   # 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 [](key)
       key = _match_key(key)
       super
@@ -27,14 +25,12 @@ module IceCube
 
     def _match_key(key)
       return key if __getobj__.has_key? key
-      if Symbol == key.class
+      if key.instance_of?(Symbol)
         __getobj__.keys.detect { |k| return k if k == key.to_s }
-      elsif String == key.class
+      elsif key.instance_of?(String)
         __getobj__.keys.detect { |k| return k if k.to_s == key }
       end
       key
     end
-
   end
-
 end

data/lib/ice_cube/i18n.rb

@@ -1,27 +1,15 @@
-require 'ice_cube/null_i18n'
+require "ice_cube/null_i18n"
 
 module IceCube
-  module I18n
-
-    LOCALES_PATH = File.expand_path(File.join('..', '..', '..', 'config', 'locales'), __FILE__)
-
-    def self.t(*args)
-      backend.t(*args)
-    end
-
-    def self.l(*args)
-      backend.l(*args)
-    end
-
-    def self.backend
-      @backend ||= detect_backend!
-    end
-
-    def self.detect_backend!
-      ::I18n.load_path += Dir[File.join(LOCALES_PATH, '*.yml')]
-      ::I18n
-    rescue NameError
-      NullI18n
-    end
+  LOCALES_PATH = File.expand_path(File.join("..", "..", "config", "locales"), __dir__)
+
+  # rubocop:disable Naming/ConstantName
+  I18n = begin
+    require "i18n"
+    ::I18n.load_path += Dir[File.join(LOCALES_PATH, "*.yml")]
+    ::I18n
+  rescue LoadError
+    NullI18n
   end
+  # rubocop:enable Naming/ConstantName
 end

data/lib/ice_cube/input_alignment.rb

@@ -1,6 +1,5 @@
 module IceCube
   class InputAlignment
-
     def initialize(rule, value, rule_part)
       @rule = rule
       @value = value
@@ -9,16 +8,16 @@ module IceCube
 
     attr_reader :rule, :value, :rule_part
 
-    def verify(freq, options={}, &block)
+    def verify(freq, options = {}, &)
       @rule.validations[:interval] or return
 
       case @rule
       when DailyRule
-        verify_wday_alignment(freq, &block)
+        verify_wday_alignment(freq, &)
       when MonthlyRule
-        verify_month_alignment(freq, &block)
+        verify_month_alignment(freq, &)
       else
-        verify_freq_alignment(freq, &block)
+        verify_freq_alignment(freq, &)
       end
     end
 
@@ -34,7 +33,7 @@ module IceCube
 
     def fixed_validations
       @fixed_validations ||= @rule.validations.values.flatten.select { |v|
-        interval_type = (v.type == :wday ? :day : v.type)
+        interval_type = ((v.type == :wday) ? :day : v.type)
         v.class < Validations::FixedValue &&
           interval_type == rule.base_interval_validation.type
       }
@@ -47,13 +46,13 @@ module IceCube
       alignment = (value - last_validation.value) % interval_validation.interval
       return if alignment.zero?
 
-      validation_values = fixed_validations.map(&:value).join(', ')
-      if rule_part == :interval
-        message = "interval(#{value}) " \
+      validation_values = fixed_validations.map(&:value).join(", ")
+      message = if rule_part == :interval
+        "interval(#{value}) " \
                   "must be a multiple of " \
                   "intervals in #{last_validation.key}(#{validation_values})"
       else
-        message = "intervals in #{last_validation.key}(#{validation_values}, #{value}) " \
+        "intervals in #{last_validation.key}(#{validation_values}, #{value}) " \
                   "must be multiples of " \
                   "interval(#{interval_validation.interval})"
       end
@@ -84,6 +83,5 @@ module IceCube
 
       yield ArgumentError.new(message)
     end
-
   end
 end

data/lib/ice_cube/null_i18n.rb

@@ -1,11 +1,11 @@
-require 'yaml'
+require "yaml"
 
 module IceCube
   module NullI18n
     def self.t(key, options = {})
-      base = key.to_s.split('.').reduce(config) { |hash, current_key| hash[current_key] }
+      base = key.to_s.split(".").reduce(config) { |hash, current_key| hash[current_key] }
 
-      base = base[options[:count] == 1 ? "one" : "other"] if options[:count]
+      base = base[(options[:count] == 1) ? "one" : "other"] if options[:count]
 
       case base
       when Hash
@@ -17,18 +17,18 @@ module IceCube
           hash[k] = v
         end
       else
-        return base unless base.include?('%{')
+        return base unless base.include?("%{")
         base % options
       end
     end
 
     def self.l(date_or_time, options = {})
       return date_or_time.strftime(options[:format]) if options[:format]
-      date_or_time.strftime(t('ice_cube.date.formats.default'))
+      date_or_time.strftime(t("ice_cube.date.formats.default"))
     end
 
     def self.config
-      @config ||= YAML.load_file(File.join(IceCube::I18n::LOCALES_PATH, 'en.yml'))['en']
+      @config ||= YAML.load_file(File.join(IceCube::I18n::LOCALES_PATH, "en.yml"))["en"]
     end
   end
 end

data/lib/ice_cube/occurrence.rb

@@ -1,7 +1,6 @@
-require 'delegate'
+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:
@@ -23,14 +22,14 @@ module IceCube
 
     # Report class name as 'Time' to thwart type checking.
     def self.name
-      'Time'
+      "Time"
     end
 
     attr_reader :start_time, :end_time
-    alias first start_time
-    alias last end_time
+    alias_method :first, :start_time
+    alias_method :last, :end_time
 
-    def initialize(start_time, end_time=nil)
+    def initialize(start_time, end_time = nil)
       @start_time = start_time
       @end_time = end_time || start_time
       __setobj__ @start_time
@@ -52,10 +51,10 @@ module IceCube
     def intersects?(other)
       return cover?(other) unless other.is_a?(Occurrence) || other.is_a?(Range)
 
-      this_start  = first + 1
-      this_end    = last # exclude end boundary
+      this_start = first + 1
+      this_end = last # exclude end boundary
       other_start = other.first + 1
-      other_end   = other.last + 1
+      other_end = other.last + 1
 
       !(this_end < other_start || this_start > other_end)
     end
@@ -85,13 +84,13 @@ module IceCube
     # Optional format argument (e.g. :long, :short) supports Rails
     # time formats and is only used when ActiveSupport is available.
     #
-    def to_s(format=nil)
+    def to_s(format = nil)
       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
       end
-      duration > 0 ? "#{t0} - #{t1}" : t0
+      (duration > 0) ? "#{t0} - #{t1}" : t0
     end
 
     def overnight?

data/lib/ice_cube/parsers/hash_parser.rb

@@ -1,6 +1,5 @@
 module IceCube
   class HashParser
-
     attr_reader :hash
 
     def initialize(original_hash)
@@ -26,13 +25,13 @@ module IceCube
       data = IceCube::FlexibleHash.new(hash.dup)
 
       if (start_date = data.delete(:start_date))
-        warn "IceCube: :start_date is deprecated, please use :start_time at: #{ caller[0] }"
+        warn "IceCube: :start_date is deprecated, please use :start_time at: #{caller(1..1).first}"
         data[:start_time] = start_date
       end
 
-      {:rdates => :rtimes, :exdates => :extimes}.each do |old_key, new_key|
+      {rdates: :rtimes, exdates: :extimes}.each do |old_key, new_key|
         if (times = data.delete(old_key))
-          warn "IceCube: :#{old_key} is deprecated, please use :#{new_key} at: #{ caller[0] }"
+          warn "IceCube: :#{old_key} is deprecated, please use :#{new_key} at: #{caller(1..1).first}"
           (data[new_key] ||= []).concat times
         end
       end
@@ -61,7 +60,6 @@ module IceCube
 
     def apply_exrules(schedule, data)
       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|
         rrule = h.is_a?(IceCube::Rule) ? h : IceCube::Rule.from_hash(h)
 
@@ -86,6 +84,5 @@ module IceCube
     def parse_time(time)
       TimeUtil.deserialize_time(time)
     end
-
   end
 end

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