ice_cube 0.16.3 → 0.17.0

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

data/lib/ice_cube/time_util.rb

@@ -1,31 +1,30 @@
-require 'date'
-require 'time'
+require "date"
+require "time"
 
 module IceCube
   module TimeUtil
-
     extend Deprecated
 
     DAYS = {
-      :sunday => 0, :monday => 1, :tuesday => 2, :wednesday => 3,
-      :thursday => 4, :friday => 5, :saturday => 6
+      sunday: 0, monday: 1, tuesday: 2, wednesday: 3,
+      thursday: 4, friday: 5, saturday: 6
     }
 
     ICAL_DAYS = {
-      'SU' => :sunday, 'MO' => :monday, 'TU' => :tuesday, 'WE' => :wednesday,
-      'TH' => :thursday, 'FR' => :friday, 'SA' => :saturday
+      "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,
-      :november => 11, :december => 12
+      january: 1, february: 2, march: 3, april: 4, may: 5,
+      june: 6, july: 7, august: 8, september: 9, october: 10,
+      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)
+    def self.now(reference = Time.now)
       match_zone(Time.at(Time.now.to_i), reference)
     end
 
@@ -42,18 +41,16 @@ module IceCube
     end
 
     def self.match_zone(input_time, reference)
-      return unless time = ensure_time(input_time, reference)
+      return unless (time = ensure_time(input_time, reference))
       time = if reference.respond_to? :time_zone
-               time.in_time_zone(reference.time_zone)
-             else
-               if reference.utc?
-                 time.getgm
-               elsif reference.zone
-                 time.getlocal
-               else
-                 time.getlocal(reference.utc_offset)
-               end
-             end
+        time.in_time_zone(reference.time_zone)
+      elsif reference.utc?
+        time.getgm
+      elsif reference.zone
+        time.getlocal
+      else
+        time.getlocal(reference.utc_offset)
+      end
       (Date === input_time) ? beginning_of_date(time, reference) : time
     end
 
@@ -61,17 +58,15 @@ module IceCube
     def self.ensure_time(time, reference = nil, date_eod = false)
       case time
       when DateTime
-        warn "IceCube: DateTime support is deprecated (please use Time) at: #{ caller[2] }"
+        warn "IceCube: DateTime support is deprecated (please use Time) at: #{caller(3..3).first}"
         Time.local(time.year, time.month, time.day, time.hour, time.min, time.sec)
       when Date
         if date_eod
           end_of_date(time, reference)
+        elsif reference
+          build_in_zone([time.year, time.month, time.day], reference)
         else
-          if reference
-            build_in_zone([time.year, time.month, time.day], reference)
-          else
-            time.to_time
-          end
+          time.to_time
         end
       else
         time
@@ -83,7 +78,7 @@ module IceCube
       case date
       when Date then date
       else
-        return Date.new(date.year, date.month, date.day)
+        Date.new(date.year, date.month, date.day)
       end
     end
 
@@ -92,7 +87,7 @@ module IceCube
       case time
       when Time, Date
         if time.respond_to?(:time_zone)
-          {:time => time.utc, :zone => time.time_zone.name}
+          {time: time.utc, zone: time.time_zone.name}
         else
           time
         end
@@ -133,18 +128,18 @@ module IceCube
     # will lose the zone and not support DST.
     def self.restore_deserialized_offset(time, orig_offset_str)
       return time if time.respond_to?(:time_zone) ||
-                     time.getlocal(orig_offset_str).utc_offset == time.utc_offset
-      warn "IceCube: parsed Time from nonlocal TZ. Use ActiveSupport to fix DST at: #{ caller[0] }"
+        time.getlocal(orig_offset_str).utc_offset == time.utc_offset
+      warn "IceCube: parsed Time from nonlocal TZ. Use ActiveSupport to fix DST at: #{caller(1..1).first}"
       time.localtime(orig_offset_str)
     end
 
     # Get the beginning of a date
-    def self.beginning_of_date(date, reference=Time.now)
+    def self.beginning_of_date(date, reference = 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=Time.now)
+    def self.end_of_date(date, reference = Time.now)
       build_in_zone([date.year, date.month, date.day, 23, 59, 59], reference)
     end
 
@@ -152,8 +147,8 @@ module IceCube
     def self.sym_to_month(sym)
       MONTHS.fetch(sym) do |k|
         MONTHS.values.detect { |i| i.to_s == k.to_s } or
-        raise ArgumentError, "Expecting Integer or Symbol value for month. " \
-                             "No such month: #{k.inspect}"
+          raise ArgumentError, "Expecting Integer or Symbol value for month. " \
+                               "No such month: #{k.inspect}"
       end
     end
     deprecated_alias :symbol_to_month, :sym_to_month
@@ -162,15 +157,15 @@ module IceCube
     def self.sym_to_wday(sym)
       DAYS.fetch(sym) do |k|
         DAYS.values.detect { |i| i.to_s == k.to_s } or
-        raise ArgumentError, "Expecting Integer or Symbol value for weekday. " \
-                             "No such weekday: #{k.inspect}"
+          raise ArgumentError, "Expecting Integer or Symbol value for weekday. " \
+                               "No such weekday: #{k.inspect}"
       end
     end
     deprecated_alias :symbol_to_day, :sym_to_wday
 
     # Convert wday number to day symbol
     def self.wday_to_sym(wday)
-      return wday if DAYS.keys.include? wday
+      return wday if DAYS.key? wday
       DAYS.invert.fetch(wday) do |i|
         raise ArgumentError, "Expecting Integer value for weekday. " \
                              "No such wday number: #{i.inspect}"
@@ -270,14 +265,13 @@ module IceCube
 
     # A utility class for safely moving time around
     class TimeWrapper
-
       def initialize(time, dst_adjust = true)
         @dst_adjust = dst_adjust
         @base = time
-        if dst_adjust
-          @time = Time.utc(time.year, time.month, time.day, time.hour, time.min, time.sec + TimeUtil.subsec(time))
+        @time = if dst_adjust
+          Time.utc(time.year, time.month, time.day, time.hour, time.min, time.sec + TimeUtil.subsec(time))
         else
-          @time = time
+          time
         end
       end
 
@@ -292,13 +286,13 @@ module IceCube
       def add(type, val)
         type = :day if type == :wday
         @time += case type
-                 when :year then TimeUtil.days_in_n_years(@time, val) * ONE_DAY
-                 when :month then TimeUtil.days_in_n_months(@time, val) * ONE_DAY
-                 when :day  then val * ONE_DAY
-                 when :hour then val * ONE_HOUR
-                 when :min  then val * ONE_MINUTE
-                 when :sec  then val
-                 end
+        when :year then TimeUtil.days_in_n_years(@time, val) * ONE_DAY
+        when :month then TimeUtil.days_in_n_months(@time, val) * ONE_DAY
+        when :day then val * ONE_DAY
+        when :hour then val * ONE_HOUR
+        when :min then val * ONE_MINUTE
+        when :sec then val
+        end
       end
 
       # Clear everything below a certain type
@@ -320,24 +314,24 @@ module IceCube
       end
 
       def sec=(value)
-        @time += (value) - (@time.sec)
+        @time += value - @time.sec
       end
 
       def clear_sec
-        @time.sec > 0 ? @time -= @time.sec : @time
+        (@time.sec > 0) ? @time -= @time.sec : @time
       end
 
       def clear_min
-        @time.min > 0 ? @time -= (@time.min * ONE_MINUTE) : @time
+        (@time.min > 0) ? @time -= (@time.min * ONE_MINUTE) : @time
       end
 
       def clear_hour
-        @time.hour > 0 ? @time -= (@time.hour * ONE_HOUR) : @time
+        (@time.hour > 0) ? @time -= (@time.hour * ONE_HOUR) : @time
       end
 
       # Move to the first of the month, 0 hours
       def clear_day
-        @time.day > 1 ? @time -= (@time.day - 1) * ONE_DAY : @time
+        (@time.day > 1) ? @time -= (@time.day - 1) * ONE_DAY : @time
       end
 
       # Clear to january 1st
@@ -348,8 +342,6 @@ module IceCube
         end
         @time += ONE_DAY
       end
-
     end
-
   end
 end

data/lib/ice_cube/validated_rule.rb

@@ -1,9 +1,7 @@
-require 'ice_cube/input_alignment'
+require "ice_cube/input_alignment"
 
 module IceCube
-
   class ValidatedRule < Rule
-
     include Validations::ScheduleLock
 
     include Validations::Count
@@ -26,7 +24,7 @@ module IceCube
     attr_reader :validations
 
     def initialize(interval = 1)
-      @validations = Hash.new
+      @validations = {}
     end
 
     # Reset the uses on the rule to 0
@@ -48,10 +46,8 @@ module IceCube
     # to the given start time
     def next_time(time, start_time, closing_time)
       @time = time
-      unless @start_time
-        @start_time = realign(time, start_time)
-        @time = @start_time if @time < @start_time
-      end
+      @start_time ||= realign(time, start_time)
+      @time = @start_time if @time < @start_time
 
       return nil unless find_acceptable_time_before(closing_time)
 
@@ -183,7 +179,5 @@ module IceCube
         yield error
       end
     end
-
   end
-
 end

data/lib/ice_cube/validations/count.rb

@@ -1,7 +1,5 @@
 module IceCube
-
   module Validations::Count
-
     # Value reader for limit
     def occurrence_count
       (arr = @validations[:count]) && (val = arr[0]) && val.count
@@ -16,7 +14,6 @@ module IceCube
     end
 
     class Validation
-
       attr_reader :rule, :count
 
       def initialize(count, rule)
@@ -45,16 +42,13 @@ module IceCube
       end
 
       def build_ical(builder)
-        builder['COUNT'] << count
+        builder["COUNT"] << count
       end
 
       StringBuilder.register_formatter(:count) do |segments|
         count = segments.first
-        IceCube::I18n.t('ice_cube.times', count: count)
+        IceCube::I18n.t("ice_cube.times", count: count)
       end
-
     end
-
   end
-
 end

data/lib/ice_cube/validations/daily_interval.rb

@@ -1,12 +1,10 @@
 module IceCube
-
   module Validations::DailyInterval
-
     # Add a new interval validation
     def interval(interval)
       interval = normalized_interval(interval)
       verify_alignment(interval, :wday, :interval) { |error| raise error }
-      verify_alignment(interval, :day, :interval)  { |error| raise error }
+      verify_alignment(interval, :day, :interval) { |error| raise error }
 
       @interval = interval
       replace_validations_for(:interval, [Validation.new(@interval)])
@@ -15,7 +13,6 @@ module IceCube
     end
 
     class Validation
-
       attr_reader :interval
 
       def initialize(interval)
@@ -33,13 +30,13 @@ module IceCube
       def validate(step_time, start_time)
         t0, t1 = start_time, step_time
         days = Date.new(t1.year, t1.month, t1.day) -
-               Date.new(t0.year, t0.month, t0.day)
+          Date.new(t0.year, t0.month, t0.day)
         offset = (days % interval).nonzero?
         interval - offset if offset
       end
 
       def build_s(builder)
-        builder.base = IceCube::I18n.t('ice_cube.each_day', count: interval)
+        builder.base = IceCube::I18n.t("ice_cube.each_day", count: interval)
       end
 
       def build_hash(builder)
@@ -47,12 +44,9 @@ module IceCube
       end
 
       def build_ical(builder)
-        builder['FREQ'] << 'DAILY'
-        builder['INTERVAL'] << interval unless interval == 1
+        builder["FREQ"] << "DAILY"
+        builder["INTERVAL"] << interval unless interval == 1
       end
-
     end
-
   end
-
 end

data/lib/ice_cube/validations/day.rb

@@ -1,7 +1,5 @@
 module IceCube
-
   module Validations::Day
-
     def day(*days)
       days = days.flatten
       return self if days.empty?
@@ -19,9 +17,8 @@ module IceCube
     end
 
     class Validation < Validations::FixedValue
-
       attr_reader :day
-      alias :value :day
+      alias_method :value, :day
 
       def initialize(day)
         @day = day
@@ -50,8 +47,8 @@ module IceCube
       def build_ical(builder)
         ical_day = IcalBuilder.fixnum_to_ical_day(day)
         # Only add if there aren't others from day_of_week that override
-        if builder['BYDAY'].none? { |b| b.end_with?(ical_day) }
-          builder['BYDAY'] << ical_day
+        if builder["BYDAY"].none? { |b| b.end_with?(ical_day) }
+          builder["BYDAY"] << ical_day
         end
       end
 
@@ -60,18 +57,15 @@ module IceCube
         validation_days.sort!
         # pick the right shortening, if applicable
         if validation_days == [0, 6]
-          IceCube::I18n.t('ice_cube.on_weekends')
+          IceCube::I18n.t("ice_cube.on_weekends")
         elsif validation_days == (1..5).to_a
-          IceCube::I18n.t('ice_cube.on_weekdays')
+          IceCube::I18n.t("ice_cube.on_weekdays")
         else
-          day_names = ->(d){ "#{IceCube::I18n.t("ice_cube.days_on")[d]}" }
+          day_names = ->(d) { (IceCube::I18n.t("ice_cube.days_on")[d]).to_s }
           segments = validation_days.map(&day_names)
-          IceCube::I18n.t('ice_cube.on_days', days: StringBuilder.sentence(segments))
+          IceCube::I18n.t("ice_cube.on_days", days: StringBuilder.sentence(segments))
         end
       end
-
     end
-
   end
-
 end