ice_cube 0.16.0 → 0.16.4

data/config/locales/pt-BR.yml

@@ -0,0 +1,178 @@
+pt-BR:
+  ice_cube:
+    pieces_connector: ' / '
+    not: 'exceto %{target}'
+    not_on: 'exceto o dia %{target}'
+    date:
+      formats:
+        default: '%-d %B %Y'
+      month_names:
+      -
+      - Janeiro
+      - Fevereiro
+      - Março
+      - Abril
+      - Maio
+      - Junho
+      - Julho
+      - Agosto
+      - Setembro
+      - Outubro
+      - Novembro
+      - Dezembro
+      day_names:
+      - Domingo
+      - Segunda
+      - Terça
+      - Quarta
+      - Quinta
+      - Sexta
+      - Sábado
+    times:
+      other: '%{count} vezes'
+      one: '%{count} vez'
+    until: 'até %{date}'
+    days_of_week: '%{segments} %{day}'
+    days_of_month:
+      other: '%{segments} dias do mês'
+      one: '%{segments} dia'
+    days_of_year:
+      other: '%{segments} dias do ano'
+      one: '%{segments} dia'
+    at_hours_of_the_day:
+      other: às %{segments} horas
+      one: à %{segments} hora
+    on_minutes_of_hour:
+      other: aos %{segments} minutos
+      one: ao %{segments} minuto
+    at_seconds_of_minute:
+      other: aos %{segments} segundos
+      one: ao %{segments} segundo
+    on_seconds_of_minute:
+      other: aos %{segments} segundos
+      one: ao %{segments} segundo
+    each_second:
+      one: A cada segundo
+      other: A cada %{count} segundos
+    each_minute:
+      one: A cada minuto
+      other: A cada %{count} minutos
+    each_hour:
+      one: A cada hora
+      other: A cada %{count} horas
+    each_day:
+      one: Diariamente
+      other: A cada %{count} dias
+    each_week:
+      one: Semanalmente
+      other: A cada %{count} semanas
+    each_month:
+      one: Mensalmente
+      other: A cada %{count} meses
+    each_year:
+      one: Anualmente
+      other: A cada %{count} anos
+    'on': no %{sentence}
+    in: 'em %{target}'
+    integer:
+      negative: '%{ordinal} depois que acabar'
+      literal_ordinals:
+        -1: último
+        -2: penúltimo
+      ordinal: '%{number}%{ordinal}'
+      ordinals:
+        default: º
+        1: º
+        2: º
+        3: º
+        11: º
+        12: º
+        13: º
+    on_weekends: nos finais de semana
+    on_weekdays: nos dias úteis
+    days_on:
+      - Domingos
+      - Segundas-feiras
+      - Terças-feiras
+      - Quartas-feiras
+      - Quintas-feiras
+      - Sextas-feiras
+      - Sábados
+    on_days: no dia %{days}
+    array:
+      last_word_connector: ' e '
+      two_words_connector: ' e '
+      words_connector: ', '
+    string:
+      format:
+        day: '%{rest} %{current}'
+        day_of_week: '%{rest} %{current}'
+        day_of_month: '%{rest} %{current}'
+        day_of_year: '%{rest} %{current}'
+        hour_of_day: '%{rest} %{current}'
+        minute_of_hour: '%{rest} %{current}'
+        until: '%{rest} %{current}'
+        count: '%{rest} %{current}'
+        default: '%{rest} %{current}'
+
+  date:
+    abbr_day_names:
+    - Dom
+    - Seg
+    - Ter
+    - Qua
+    - Qui
+    - Sex
+    - Sáb
+    abbr_month_names:
+    -
+    - Jan
+    - Fev
+    - Mar
+    - Abr
+    - Mai
+    - Jun
+    - Jul
+    - Ago
+    - Set
+    - Out
+    - Nov
+    - Dez
+    day_names:
+    - Domingo
+    - Segunda-feira
+    - Terça-feira
+    - Quarta-feira
+    - Quinta-feira
+    - Sexta-feira
+    - Sábado
+    formats:
+      default: "%d/%m/%Y"
+      long: "%d de %B de %Y"
+      short: "%d de %B"
+    month_names:
+    -
+    - Janeiro
+    - Fevereiro
+    - Março
+    - Abril
+    - Maio
+    - Junho
+    - Julho
+    - Agosto
+    - Setembro
+    - Outubro
+    - Novembro
+    - Dezembro
+    order:
+    - :day
+    - :month
+    - :year
+
+  time:
+    am: ''
+    formats:
+      default: "%a, %d de %B de %Y, %H:%M:%S %z"
+      long: "%d de %B de %Y, %H:%M"
+      short: "%d de %B, %H:%M"
+    pm: ''

data/config/locales/sv.yml

@@ -127,7 +127,7 @@ sv:
     - Aug
     - Sep
     - Okt
-    - Mov
+    - Nov
     - Dec
     day_names:
     - Söndag

data/lib/ice_cube/i18n.rb

@@ -1,24 +1,23 @@
+require 'ice_cube/null_i18n'
+
 module IceCube
   module I18n
-    def self.t(*args)
-      backend.t(*args)
-    end
 
-    def self.l(*args)
-      backend.l(*args)
+    LOCALES_PATH = File.expand_path(File.join('..', '..', '..', 'config', 'locales'), __FILE__)
+
+    class << self
+      delegate :t, :l, to: :backend
     end
 
     def self.backend
-      @backend
+      @backend ||= detect_backend!
     end
 
     def self.detect_backend!
-      require 'i18n'
-      ::I18n.load_path += Dir[File.expand_path('../../../config/locales/*{rb,yml}', __FILE__)]
-      @backend = ::I18n
-    rescue LoadError
-      require 'ice_cube/null_i18n'
-      @backend = NullI18n
+      ::I18n.load_path += Dir[File.join(LOCALES_PATH, '*.yml')]
+      ::I18n
+    rescue NameError
+      NullI18n
     end
   end
 end

data/lib/ice_cube/input_alignment.rb

@@ -0,0 +1,89 @@
+module IceCube
+  class InputAlignment
+
+    def initialize(rule, value, rule_part)
+      @rule = rule
+      @value = value
+      @rule_part = rule_part
+    end
+
+    attr_reader :rule, :value, :rule_part
+
+    def verify(freq, options={}, &block)
+      @rule.validations[:interval] or return
+
+      case @rule
+      when DailyRule
+        verify_wday_alignment(freq, &block)
+      when MonthlyRule
+        verify_month_alignment(freq, &block)
+      else
+        verify_freq_alignment(freq, &block)
+      end
+    end
+
+    private
+
+    def interval_validation
+      @interval_validation ||= @rule.validations[:interval].first
+    end
+
+    def interval_value
+      @interval_value ||= (rule_part == :interval) ? value : interval_validation.interval
+    end
+
+    def fixed_validations
+      @fixed_validations ||= @rule.validations.values.flatten.select { |v|
+        interval_type = (v.type == :wday ? :day : v.type)
+        v.class < Validations::FixedValue &&
+          interval_type == rule.base_interval_validation.type
+      }
+    end
+
+    def verify_freq_alignment(freq)
+      interval_validation.type == freq or return
+      (last_validation = fixed_validations.min_by(&:value)) or return
+
+      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}) " \
+                  "must be a multiple of " \
+                  "intervals in #{last_validation.key}(#{validation_values})"
+      else
+        message = "intervals in #{last_validation.key}(#{validation_values}, #{value}) " \
+                  "must be multiples of " \
+                  "interval(#{interval_validation.interval})"
+      end
+
+      yield ArgumentError.new(message)
+    end
+
+    def verify_month_alignment(_freq)
+      return if interval_value == 1 || (interval_value % 12).zero?
+      return if fixed_validations.empty?
+
+      message = "month_of_year can only be used with interval(1) or multiples of interval(12)"
+
+      yield ArgumentError.new(message)
+    end
+
+    def verify_wday_alignment(freq)
+      return if interval_value == 1
+
+      if freq == :wday
+        return if (interval_value % 7).zero?
+        return if Array(@rule.validations[:day]).empty?
+        message = "day can only be used with multiples of interval(7)"
+      else
+        (fixed_validation = fixed_validations.first) or return
+        message = "#{fixed_validation.key} can only be used with interval(1)"
+      end
+
+      yield ArgumentError.new(message)
+    end
+
+  end
+end

data/lib/ice_cube/null_i18n.rb

@@ -7,13 +7,19 @@ module IceCube
 
       base = base[options[:count] == 1 ? "one" : "other"] if options[:count]
 
-      if base.is_a?(Hash)
-        return base.each_with_object({}) do |(key, value), hash|
-          hash[key.is_a?(String) ? key.to_sym : key] = value
+      case base
+      when Hash
+        base.each_with_object({}) do |(k, v), hash|
+          hash[k.is_a?(String) ? k.to_sym : k] = v
         end
+      when Array
+        base.each_with_index.each_with_object({}) do |(v, k), hash|
+          hash[k] = v
+        end
+      else
+        return base unless base.include?('%{')
+        base % options
       end
-
-      options.reduce(base) { |result, (find, replace)| result.gsub("%{#{find}}", "#{replace}") }
     end
 
     def self.l(date_or_time, options = {})
@@ -22,7 +28,7 @@ module IceCube
     end
 
     def self.config
-      @config ||= YAML.load(File.read(File.join(File.dirname(__FILE__), '..', '..', 'config', 'locales', '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,4 +1,3 @@
-require 'forwardable'
 require 'delegate'
 
 module IceCube
@@ -20,18 +19,16 @@ module IceCube
   #     Time.now - Occurrence.new(start_time) # => 3600
   #
   class Occurrence < SimpleDelegator
+    include Comparable
 
     # Report class name as 'Time' to thwart type checking.
     def self.name
       'Time'
     end
 
-    # Optimize for common methods to avoid method_missing
-    extend Forwardable
-    def_delegators :start_time, :to_i, :<=>, :==
-    def_delegators :to_range, :cover?, :include?, :each, :first, :last
-
     attr_reader :start_time, :end_time
+    alias first start_time
+    alias last end_time
 
     def initialize(start_time, end_time=nil)
       @start_time = start_time
@@ -39,29 +36,34 @@ module IceCube
       __setobj__ @start_time
     end
 
+    def to_i
+      @start_time.to_i
+    end
+
+    def <=>(other)
+      @start_time <=> other
+    end
+
     def is_a?(klass)
       klass == ::Time || super
     end
     alias_method :kind_of?, :is_a?
 
-    def intersects? other
-      if other.is_a?(Occurrence) || other.is_a?(Range)
-        lower_bound_1 = first + 1
-        upper_bound_1 = last # exclude end
-        lower_bound_2 = other.first + 1
-        upper_bound_2 = other.last + 1
-        if (lower_bound_2 <=> upper_bound_2) > 0
-          false
-        elsif (lower_bound_1 <=> upper_bound_1) > 0
-          false
-        else
-          (upper_bound_1 <=> lower_bound_2) >= 0 and
-            (upper_bound_2 <=> lower_bound_1) >= 0
-        end
-      else
-        cover? other
-      end
+    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
+      other_start = other.first + 1
+      other_end   = other.last + 1
+
+      !(this_end < other_start || this_start > other_end)
+    end
+
+    def cover?(other)
+      to_range.cover?(other)
     end
+    alias_method :include?, :cover?
 
     def comparable_time
       start_time

data/lib/ice_cube/parsers/ical_parser.rb

@@ -4,15 +4,18 @@ module IceCube
       data = {}
       ical_string.each_line do |line|
         (property, value) = line.split(':')
-        (property, tzid) = property.split(';')
+        (property, _tzid) = property.split(';')
         case property
         when 'DTSTART'
-          data[:start_time] = Time.parse(value)
+          data[:start_time] = TimeUtil.deserialize_time(value)
         when 'DTEND'
-          data[:end_time] = Time.parse(value)
+          data[:end_time] = TimeUtil.deserialize_time(value)
+        when 'RDATE'
+          data[:rtimes] ||= []
+          data[:rtimes] += value.split(',').map { |v| TimeUtil.deserialize_time(v) }
         when 'EXDATE'
           data[:extimes] ||= []
-          data[:extimes] += value.split(',').map{|v| Time.parse(v)}
+          data[:extimes] += value.split(',').map { |v| TimeUtil.deserialize_time(v) }
         when 'DURATION'
           data[:duration] # FIXME
         when 'RRULE'
@@ -41,7 +44,7 @@ module IceCube
         when 'COUNT'
           params[:count] = value.to_i
         when 'UNTIL'
-          params[:until] = Time.parse(value).utc
+          params[:until] = TimeUtil.deserialize_time(value).utc
         when 'WKST'
           params[:week_start] = TimeUtil.ical_day_to_symbol(value)
         when 'BYSECOND'

data/lib/ice_cube/rule.rb

@@ -19,20 +19,17 @@ module IceCube
       until_time || occurrence_count
     end
 
-    def ==(rule)
-      if rule.is_a? Rule
-        hash = to_hash
-        hash && hash == rule.to_hash
-      end
+    def ==(other)
+      return false unless other.is_a? Rule
+      hash == other.hash
     end
 
     def hash
-      h = to_hash
-      h.nil? ? super : h.hash
+      to_hash.hash
     end
 
     def to_ical
-      raise MethodNotImplemented, "Expected to be overrridden by subclasses"
+      raise MethodNotImplemented, "Expected to be overridden by subclasses"
     end
 
     # Convert from ical string and create a rule
@@ -61,11 +58,6 @@ module IceCube
       next_time(time, schedule, time).to_i == time.to_i
     end
 
-    # Whether this rule requires a full run
-    def full_required?
-      !@count.nil?
-    end
-
     class << self
 
       # Convert from a hash and create a rule

data/lib/ice_cube/rules/daily_rule.rb

@@ -2,6 +2,15 @@ module IceCube
 
   class DailyRule < ValidatedRule
 
+    include Validations::HourOfDay
+    include Validations::MinuteOfHour
+    include Validations::SecondOfMinute
+    include Validations::DayOfMonth
+    include Validations::DayOfWeek
+    include Validations::Day
+    include Validations::MonthOfYear
+    # include Validations::DayOfYear    # n/a
+
     include Validations::DailyInterval
 
     def initialize(interval = 1)

data/lib/ice_cube/rules/hourly_rule.rb

@@ -2,6 +2,15 @@ module IceCube
 
   class HourlyRule < ValidatedRule
 
+    include Validations::HourOfDay
+    include Validations::MinuteOfHour
+    include Validations::SecondOfMinute
+    include Validations::DayOfMonth
+    include Validations::DayOfWeek
+    include Validations::Day
+    include Validations::MonthOfYear
+    include Validations::DayOfYear
+
     include Validations::HourlyInterval
 
     def initialize(interval = 1)

data/lib/ice_cube/rules/minutely_rule.rb

@@ -2,6 +2,15 @@ module IceCube
 
   class MinutelyRule < ValidatedRule
 
+    include Validations::HourOfDay
+    include Validations::MinuteOfHour
+    include Validations::SecondOfMinute
+    include Validations::DayOfMonth
+    include Validations::DayOfWeek
+    include Validations::Day
+    include Validations::MonthOfYear
+    include Validations::DayOfYear
+
     include Validations::MinutelyInterval
 
     def initialize(interval = 1)

data/lib/ice_cube/rules/monthly_rule.rb

@@ -2,6 +2,15 @@ module IceCube
 
   class MonthlyRule < ValidatedRule
 
+    include Validations::HourOfDay
+    include Validations::MinuteOfHour
+    include Validations::SecondOfMinute
+    include Validations::DayOfMonth
+    include Validations::DayOfWeek
+    include Validations::Day
+    include Validations::MonthOfYear
+    # include Validations::DayOfYear    # n/a
+
     include Validations::MonthlyInterval
 
     def initialize(interval = 1)

data/lib/ice_cube/rules/secondly_rule.rb

@@ -2,6 +2,15 @@ module IceCube
 
   class SecondlyRule < ValidatedRule
 
+    include Validations::HourOfDay
+    include Validations::MinuteOfHour
+    include Validations::SecondOfMinute
+    include Validations::DayOfMonth
+    include Validations::DayOfWeek
+    include Validations::Day
+    include Validations::MonthOfYear
+    include Validations::DayOfYear
+
     include Validations::SecondlyInterval
 
     def initialize(interval = 1)

data/lib/ice_cube/rules/weekly_rule.rb

@@ -2,6 +2,15 @@ module IceCube
 
   class WeeklyRule < ValidatedRule
 
+    include Validations::HourOfDay
+    include Validations::MinuteOfHour
+    include Validations::SecondOfMinute
+    # include Validations::DayOfMonth   # n/a
+    include Validations::DayOfWeek
+    include Validations::Day
+    include Validations::MonthOfYear
+    # include Validations::DayOfYear    # n/a
+
     include Validations::WeeklyInterval
 
     attr_reader :week_start
@@ -13,25 +22,37 @@ module IceCube
       reset
     end
 
-    # Calculate the effective start time for when the given start time is later
-    # in the week than one of the weekday validations, such that times could be
-    # missed by a 7-day jump using the weekly interval, or when selecting from a
-    # date that is misaligned from the schedule interval.
+    # Move the effective start time to correct for when the schedule has
+    # validations earlier in the week than the selected start time, e.g.
+    #
+    #     Schedule.new(wednesday).weekly(2).day(:monday)
+    #
+    # The effective start time gets realigned to the second next Monday, jumping
+    # over the gap week for the interval (2). Without realignment, the correct
+    # Monday occurrence would be missed when the schedule performs a 7-day jump
+    # into the next interval week, arriving on the Wednesday. This corrects any
+    # selections from dates that are misaligned to the schedule interval.
     #
     def realign(step_time, start_time)
       time = TimeUtil::TimeWrapper.new(start_time)
       offset = wday_offset(step_time, start_time)
-      time.add(:day, offset) if offset
-      time.to_time
+      time.add(:day, offset)
+      super step_time, time.to_time
     end
 
+    # Calculate how many days to the first wday validation in the correct
+    # interval week. This may move backwards within the week if starting in an
+    # interval week with earlier validations.
+    #
     def wday_offset(step_time, start_time)
+      return 0 if step_time == start_time
+
       wday_validations = other_interval_validations.select { |v| v.type == :wday }
-      return if wday_validations.none?
+      return 0 if wday_validations.none?
 
-      days = (step_time - start_time).to_i / ONE_DAY
+      days = step_time.to_date - start_time.to_date
       interval = base_interval_validation.validate(step_time, start_time).to_i
-      min_wday = TimeUtil.normalize_wday(wday_validations.min_by(&:day).day, week_start)
+      min_wday = wday_validations.map { |v| TimeUtil.normalize_wday(v.day, week_start) }.min
       step_wday = TimeUtil.normalize_wday(step_time.wday, week_start)
 
       days + interval - step_wday + min_wday

data/lib/ice_cube/rules/yearly_rule.rb

@@ -2,6 +2,15 @@ module IceCube
 
   class YearlyRule < ValidatedRule
 
+    include Validations::HourOfDay
+    include Validations::MinuteOfHour
+    include Validations::SecondOfMinute
+    include Validations::DayOfMonth
+    include Validations::DayOfWeek
+    include Validations::Day
+    include Validations::MonthOfYear
+    include Validations::DayOfYear
+
     include Validations::YearlyInterval
 
     def initialize(interval = 1)