ice_cube 0.16.2 → 0.16.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 51dd94d70b0d51847c678abf736d395ddbee5e2e
-  data.tar.gz: 2b69372e7e4e67487347cab5a8a773da40a87e91
+  metadata.gz: afc29d6bebdb8a25e7926863560b6b73214887d7
+  data.tar.gz: 850cad27d4f06dd30052222e4c30f6fa8b3b50e5
 SHA512:
-  metadata.gz: d20e08c68105003f8a6c3f192c679d185c07e43681543844f890d00947d94d6c42d5e82a350e83cab506c74183bbd42eef2cb8d5deeab8f7979a819884221dff
-  data.tar.gz: f1ab8c1b534dd70e185da9b272a973202cb071f29bd90cb2a31fa7d83d1b3f0e61c321d3d402e79e0059cf698374a0465dc954218de77afe0ac459cc0f990f47
+  metadata.gz: 351c83281b34657ff2a64c8fc03e023265803ba8776d6f6a98c90fbbf04f14c0e0c9a7d7ee40f5a8c739cea31283b60c429b37521f7fe4e7ea61bc2175123c46
+  data.tar.gz: d02fba63d82b7a26077cadf400a0bd45172d6d047c26533164f786654b925e0b6e28902cefec8ada0a2df10f08596237c848271ffbb85094323ec515a71f2431

data/lib/ice_cube.rb

@@ -1,8 +1,5 @@
 require 'date'
 require 'ice_cube/deprecated'
-require 'ice_cube/i18n'
-
-IceCube::I18n.detect_backend!
 
 module IceCube
 
@@ -10,6 +7,7 @@ module IceCube
 
   autoload :TimeUtil, 'ice_cube/time_util'
   autoload :FlexibleHash, 'ice_cube/flexible_hash'
+  autoload :I18n, 'ice_cube/i18n'
 
   autoload :Rule, 'ice_cube/rule'
   autoload :Schedule, 'ice_cube/schedule'

data/lib/ice_cube/i18n.rb

@@ -1,5 +1,10 @@
+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
@@ -9,16 +14,14 @@ module IceCube
     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

@@ -7,12 +7,15 @@ module IceCube
         (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,11 +19,9 @@ 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
@@ -31,7 +29,7 @@ module IceCube
     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
@@ -60,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
@@ -28,7 +37,7 @@ module IceCube
       time = TimeUtil::TimeWrapper.new(start_time)
       offset = wday_offset(step_time, start_time)
       time.add(:day, offset)
-      time.to_time
+      super step_time, time.to_time
     end
 
     # Calculate how many days to the first wday validation in the correct

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)

data/lib/ice_cube/schedule.rb

@@ -340,9 +340,9 @@ module IceCube
       IcalParser.schedule_from_ical(ical, options)
     end
 
-    # Convert the schedule to yaml
-    def to_yaml(*args)
-      YAML::dump(to_hash, *args)
+    # Hook for YAML.dump, enables to_yaml
+    def encode_with(coder)
+      coder.represent_object nil, to_hash
     end
 
     # Load the schedule from yaml
@@ -371,6 +371,7 @@ module IceCube
       end
       data
     end
+    alias_method :to_h, :to_hash
 
     # Load the schedule from a hash
     def self.from_hash(original_hash, options = {})
@@ -383,7 +384,7 @@ module IceCube
     # Determine if the schedule will end
     # @return [Boolean] true if ending, false if repeating forever
     def terminating?
-      recurrence_rules.empty? || recurrence_rules.all?(&:terminating?)
+      @all_recurrence_rules.all?(&:terminating?)
     end
 
     def hash
@@ -423,7 +424,7 @@ module IceCube
     def enumerate_occurrences(opening_time, closing_time = nil, options = {})
       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
+      opening_time += TimeUtil.subsec(start_time) - TimeUtil.subsec(opening_time)
       opening_time = start_time if opening_time < start_time
       spans = options[:spans] == true && duration != 0
       Enumerator.new do |yielder|
@@ -445,12 +446,12 @@ module IceCube
     # Get the next time after (or including) a specific time
     def next_time(time, closing_time)
       loop do
-        min_time = recurrence_rules_with_implicit_start_occurrence.reduce(nil) do |min_time, rule|
+        min_time = recurrence_rules_with_implicit_start_occurrence.reduce(nil) do |best_time, rule|
           begin
-            new_time = rule.next_time(time, start_time, min_time || closing_time)
-            [min_time, new_time].compact.min
+            new_time = rule.next_time(time, start_time, best_time || closing_time)
+            [best_time, new_time].compact.min
           rescue StopIteration
-            min_time
+            best_time
           end
         end
         break unless min_time

data/lib/ice_cube/single_occurrence_rule.rb

@@ -23,6 +23,10 @@ module IceCube
       { :time => time }
     end
 
+    def full_required?
+      false
+    end
+
   end
 
 end

data/lib/ice_cube/time_util.rb

@@ -170,20 +170,13 @@ module IceCube
 
     # Convert wday number to day symbol
     def self.wday_to_sym(wday)
-      return sym = wday if DAYS.keys.include? wday
+      return wday if DAYS.keys.include? wday
       DAYS.invert.fetch(wday) do |i|
         raise ArgumentError, "Expecting Integer value for weekday. " \
                              "No such wday number: #{i.inspect}"
       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
@@ -260,8 +253,19 @@ module IceCube
       end
     end
 
-    def self.same_clock?(t1, t2)
-      CLOCK_VALUES.all? { |i| t1.send(i) == t2.send(i) }
+    # Handle discrepancies between various time types
+    # - Time has subsec
+    # - DateTime does not
+    # - ActiveSupport::TimeWithZone can wrap either type, depending on version
+    #   or if `parse` or `now`/`local` was used to build it.
+    def self.subsec(time)
+      if time.respond_to?(:subsec)
+        time.subsec
+      elsif time.respond_to?(:sec_fraction)
+        time.sec_fraction
+      else
+        0.0
+      end
     end
 
     # A utility class for safely moving time around
@@ -271,7 +275,7 @@ module IceCube
         @dst_adjust = dst_adjust
         @base = time
         if dst_adjust
-          @time = Time.utc(time.year, time.month, time.day, time.hour, time.min, time.sec + time.subsec)
+          @time = Time.utc(time.year, time.month, time.day, time.hour, time.min, time.sec + TimeUtil.subsec(time))
         else
           @time = time
         end
@@ -307,7 +311,17 @@ module IceCube
         end
       end
 
-      private
+      def hour=(value)
+        @time += (value * ONE_HOUR) - (@time.hour * ONE_HOUR)
+      end
+
+      def min=(value)
+        @time += (value * ONE_MINUTE) - (@time.min * ONE_MINUTE)
+      end
+
+      def sec=(value)
+        @time += (value) - (@time.sec)
+      end
 
       def clear_sec
         @time.sec > 0 ? @time -= @time.sec : @time
@@ -335,10 +349,6 @@ module IceCube
         @time += ONE_DAY
       end
 
-      def clear_year
-        @time
-      end
-
     end
 
   end

data/lib/ice_cube/validated_rule.rb

@@ -1,18 +1,11 @@
+require 'ice_cube/input_alignment'
+
 module IceCube
 
   class ValidatedRule < Rule
 
     include Validations::ScheduleLock
 
-    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::Count
     include Validations::Until
 
@@ -51,10 +44,6 @@ module IceCube
       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 start time
     def next_time(time, start_time, closing_time)
@@ -74,12 +63,8 @@ module IceCube
       start_time
     end
 
-    def skipped_for_dst
-      @uses -= 1 if @uses > 0
-    end
-
-    def dst_adjust?
-      @validations[:interval].any?(&:dst_adjust?)
+    def full_required?
+      !occurrence_count.nil?
     end
 
     def to_s
@@ -193,6 +178,12 @@ module IceCube
       VALIDATION_ORDER & @validations.keys
     end
 
+    def verify_alignment(value, freq, rule_part)
+      InputAlignment.new(self, value, rule_part).verify(freq) do |error|
+        yield error
+      end
+    end
+
   end
 
 end

data/lib/ice_cube/validations/count.rb

@@ -4,14 +4,13 @@ module IceCube
 
     # Value reader for limit
     def occurrence_count
-      @count
+      (arr = @validations[:count]) && (val = arr[0]) && val.count
     end
 
     def count(max)
       unless max.nil? || max.is_a?(Integer)
         raise ArgumentError, "Expecting Integer or nil value for count, got #{max.inspect}"
       end
-      @count = max
       replace_validations_for(:count, max && [Validation.new(max, self)])
       self
     end

data/lib/ice_cube/validations/daily_interval.rb

@@ -4,7 +4,11 @@ module IceCube
 
     # Add a new interval validation
     def interval(interval)
-      @interval = normalized_interval(interval)
+      interval = normalized_interval(interval)
+      verify_alignment(interval, :wday, :interval) { |error| raise error }
+      verify_alignment(interval, :day, :interval)  { |error| raise error }
+
+      @interval = interval
       replace_validations_for(:interval, [Validation.new(@interval)])
       clobber_base_validations(:wday, :day)
       self

data/lib/ice_cube/validations/day.rb

@@ -1,5 +1,3 @@
-require 'date'
-
 module IceCube
 
   module Validations::Day
@@ -12,6 +10,8 @@ module IceCube
           raise ArgumentError, "expecting Integer or Symbol value for day, got #{day.inspect}"
         end
         day = TimeUtil.sym_to_wday(day)
+        verify_alignment(day, :wday, :day) { |error| raise error }
+
         validations_for(:day) << Validation.new(day)
       end
       clobber_base_validations(:wday, :day)
@@ -27,6 +27,10 @@ module IceCube
         @day = day
       end
 
+      def key
+        :day
+      end
+
       def type
         :wday
       end

data/lib/ice_cube/validations/day_of_month.rb

@@ -7,6 +7,7 @@ module IceCube
         unless day.is_a?(Integer)
           raise ArgumentError, "expecting Integer value for day, got #{day.inspect}"
         end
+        verify_alignment(day, :day, :day_of_month) { |error| raise error }
         validations_for(:day_of_month) << Validation.new(day)
       end
       clobber_base_validations(:day, :wday)
@@ -22,6 +23,10 @@ module IceCube
         @day = day
       end
 
+      def key
+        :day_of_month
+      end
+
       def type
         :day
       end

data/lib/ice_cube/validations/hour_of_day.rb

@@ -8,12 +8,31 @@ module IceCube
         unless hour.is_a?(Integer)
           raise ArgumentError, "expecting Integer value for hour, got #{hour.inspect}"
         end
+
+        verify_alignment(hour, :hour, :hour_of_day) { |error| raise error }
+
         validations_for(:hour_of_day) << Validation.new(hour)
       end
       clobber_base_validations(:hour)
       self
     end
 
+    def realign(opening_time, start_time)
+      return super unless validations[:hour_of_day]
+      freq = base_interval_validation.interval
+
+      first_hour = Array(validations[:hour_of_day]).min_by(&:value)
+      time = TimeUtil::TimeWrapper.new(start_time, false)
+      if freq > 1
+        offset = first_hour.validate(opening_time, start_time)
+        time.add(:hour, offset - freq)
+      else
+        time.hour = first_hour.value
+      end
+
+      super opening_time, time.to_time
+    end
+
     class Validation < Validations::FixedValue
 
       attr_reader :hour
@@ -23,6 +42,10 @@ module IceCube
         @hour = hour
       end
 
+      def key
+        :hour_of_day
+      end
+
       def type
         :hour
       end

data/lib/ice_cube/validations/hourly_interval.rb

@@ -3,6 +3,8 @@ module IceCube
   module Validations::HourlyInterval
 
     def interval(interval)
+      verify_alignment(interval, :hour, :interval) { |error| raise error }
+
       @interval = normalized_interval(interval)
       replace_validations_for(:interval, [Validation.new(@interval)])
       clobber_base_validations(:hour)

data/lib/ice_cube/validations/minute_of_hour.rb

@@ -7,12 +7,24 @@ module IceCube
         unless minute.is_a?(Integer)
           raise ArgumentError, "expecting Integer value for minute, got #{minute.inspect}"
         end
+
+        verify_alignment(minute, :min, :minute_of_hour) { |error| raise error }
+
         validations_for(:minute_of_hour) << Validation.new(minute)
       end
       clobber_base_validations(:min)
       self
     end
 
+    def realign(opening_time, start_time)
+      return super unless validations[:minute_of_hour]
+
+      first_minute = validations[:minute_of_hour].min_by(&:value)
+      time = TimeUtil::TimeWrapper.new(start_time, false)
+      time.min = first_minute.value
+      super opening_time, time.to_time
+    end
+
     class Validation < Validations::FixedValue
 
       attr_reader :minute
@@ -22,6 +34,10 @@ module IceCube
         @minute = minute
       end
 
+      def key
+        :minute_of_hour
+      end
+
       def type
         :min
       end

data/lib/ice_cube/validations/minutely_interval.rb

@@ -3,6 +3,8 @@ module IceCube
   module Validations::MinutelyInterval
 
     def interval(interval)
+      verify_alignment(interval, :min, :interval) { |error| raise error }
+
       @interval = normalized_interval(interval)
       replace_validations_for(:interval, [Validation.new(@interval)])
       clobber_base_validations(:min)

data/lib/ice_cube/validations/month_of_year.rb

@@ -8,6 +8,7 @@ module IceCube
           raise ArgumentError, "expecting Integer or Symbol value for month, got #{month.inspect}"
         end
         month = TimeUtil.sym_to_month(month)
+        verify_alignment(month, :month, :month_of_year) { |error| raise error }
         validations_for(:month_of_year) << Validation.new(month)
       end
       clobber_base_validations :month
@@ -23,6 +24,10 @@ module IceCube
         @month = month
       end
 
+      def key
+        :month_of_year
+      end
+
       def type
         :month
       end

data/lib/ice_cube/validations/monthly_interval.rb

@@ -3,7 +3,10 @@ module IceCube
   module Validations::MonthlyInterval
 
     def interval(interval)
-      @interval = normalized_interval(interval)
+      interval = normalized_interval(interval)
+      verify_alignment(interval, :month, :interval) { |error| raise error }
+
+      @interval = interval
       replace_validations_for(:interval, [Validation.new(@interval)])
       clobber_base_validations(:month)
       self

data/lib/ice_cube/validations/schedule_lock.rb

@@ -20,6 +20,10 @@ module IceCube
         @type = type
       end
 
+      def key
+        :base
+      end
+
       def dst_adjust?
         case @type
         when :sec, :min then false

data/lib/ice_cube/validations/second_of_minute.rb

@@ -4,15 +4,27 @@ module IceCube
 
     def second_of_minute(*seconds)
       seconds.flatten.each do |second|
-      unless second.is_a?(Integer)
-        raise ArgumentError, "Expecting Integer value for second, got #{second.inspect}"
-      end
+        unless second.is_a?(Integer)
+          raise ArgumentError, "Expecting Integer value for second, got #{second.inspect}"
+        end
+
+        verify_alignment(second, :sec, :second_of_minute) { |error| raise error }
+
         validations_for(:second_of_minute) << Validation.new(second)
       end
       clobber_base_validations :sec
       self
     end
 
+    def realign(opening_time, start_time)
+      return super unless validations[:second_of_minute]
+
+      first_second = Array(validations[:second_of_minute]).min_by(&:value)
+      time = TimeUtil::TimeWrapper.new(start_time, false)
+      time.sec = first_second.value
+      super opening_time, time.to_time
+    end
+
     class Validation < Validations::FixedValue
 
       attr_reader :second
@@ -22,6 +34,10 @@ module IceCube
         @second = second
       end
 
+      def key
+        :second_of_minute
+      end
+
       def type
         :sec
       end

data/lib/ice_cube/validations/secondly_interval.rb

@@ -3,6 +3,8 @@ module IceCube
   module Validations::SecondlyInterval
 
     def interval(interval)
+      verify_alignment(interval, :sec, :interval) { |error| raise error }
+
       @interval = normalized_interval(interval)
       replace_validations_for(:interval, [Validation.new(@interval)])
       clobber_base_validations(:sec)

data/lib/ice_cube/validations/until.rb

@@ -6,12 +6,11 @@ module IceCube
 
     # Value reader for limit
     def until_time
-      @until
+      (arr = @validations[:until]) && (val = arr[0]) && val.time
     end
     deprecated_alias :until_date, :until_time
 
     def until(time)
-      @until = time
       replace_validations_for(:until, time.nil? ? nil : [Validation.new(time)])
       self
     end

data/lib/ice_cube/validations/weekly_interval.rb

@@ -1,5 +1,3 @@
-require 'date'
-
 module IceCube
 
   module Validations::WeeklyInterval

data/lib/ice_cube/version.rb

@@ -1,5 +1,5 @@
 module IceCube
 
-  VERSION = '0.16.2'
+  VERSION = '0.16.3'
 
 end

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 require "bundler/setup"
 require 'ice_cube'
+require 'timeout'
 
 begin
   require 'simplecov'
@@ -19,6 +20,17 @@ WORLD_TIME_ZONES = [
   'Pacific/Auckland',   # +1200 / +1300
 ]
 
+# TODO: enable warnings here and update specs to call IceCube objects correctly
+def Object.const_missing(sym)
+  case sym
+  when :Schedule, :Rule, :Occurrence, :TimeUtil, :ONE_DAY, :ONE_HOUR, :ONE_MINUTE
+    # warn "Use IceCube::#{sym}", caller[0]
+    IceCube.const_get(sym)
+  else
+    super
+  end
+end
+
 RSpec.configure do |config|
   # Enable flags like --only-failures and --next-failure
   config.example_status_persistence_file_path = ".rspec_status"
@@ -29,6 +41,8 @@ RSpec.configure do |config|
 
   Dir[File.dirname(__FILE__) + '/support/**/*'].each { |f| require f }
 
+  config.warnings = true
+
   config.include WarningHelpers
 
   config.before :each do |example|
@@ -37,15 +51,18 @@ RSpec.configure do |config|
     end
   end
 
-  config.around :each do |example|
-    if zone = example.metadata[:system_time_zone]
-      orig_zone = ENV['TZ']
-      ENV['TZ'] = zone
-      example.run
-      ENV['TZ'] = orig_zone
-    else
-      example.run
-    end
+  config.around :each, system_time_zone: true do |example|
+    orig_zone = ENV['TZ']
+    ENV['TZ'] = example.metadata[:system_time_zone]
+    example.run
+    ENV['TZ'] = orig_zone
+  end
+
+  config.around :each, locale: true do |example|
+    orig_locale = I18n.locale
+    I18n.locale = example.metadata[:locale]
+    example.run
+    I18n.locale = orig_locale
   end
 
   config.around :each, expect_warnings: true do |example|
@@ -53,4 +70,10 @@ RSpec.configure do |config|
       example.run
     end
   end
+
+  config.around :each do |example|
+    Timeout.timeout(example.metadata.fetch(:timeout, 1)) 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.16.2
+  version: 0.16.3
 platform: ruby
 authors:
 - John Crepezzi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-10 00:00:00.000000000 Z
+date: 2018-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -62,6 +62,7 @@ files:
 - lib/ice_cube/errors/until_exceeded.rb
 - lib/ice_cube/flexible_hash.rb
 - lib/ice_cube/i18n.rb
+- lib/ice_cube/input_alignment.rb
 - lib/ice_cube/null_i18n.rb
 - lib/ice_cube/occurrence.rb
 - lib/ice_cube/parsers/hash_parser.rb
@@ -120,8 +121,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: ice-cube
-rubygems_version: 2.6.11
+rubyforge_project: 
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: Ruby Date Recurrence Library