ice_cube 0.9.1 → 0.9.2

data/lib/ice_cube/builders/hash_builder.rb

@@ -1,7 +1,7 @@
 module IceCube
 
   class HashBuilder
-  
+
     def initialize(rule = nil)
       @hash = { :validations => {}, :rule_type => rule.class.name }
     end

data/lib/ice_cube/builders/string_builder.rb

@@ -41,8 +41,8 @@ module IceCube
     class << self
 
       NUMBER_SUFFIX = ['th', 'st', 'nd', 'rd', 'th', 'th', 'th', 'th', 'th', 'th']
-      SPECIAL_SUFFIX = { 11 => 'th', 12 => 'th', 13 => 'th', 14 => 'th' } 
- 
+      SPECIAL_SUFFIX = { 11 => 'th', 12 => 'th', 13 => 'th', 14 => 'th' }
+
       # influenced by ActiveSupport's to_sentence
       def sentence(array)
         case array.length
@@ -63,12 +63,12 @@ module IceCube
         else
           suffix = SPECIAL_SUFFIX.include?(number) ?
             SPECIAL_SUFFIX[number] : NUMBER_SUFFIX[number.abs % 10]
-          number.to_s << suffix  
+          number.to_s << suffix
         end
       end
 
     end
-  
+
   end
 
 end

data/lib/ice_cube/rule.rb

@@ -113,7 +113,7 @@ module IceCube
       end
 
     end
-    
+
   end
 
 end

data/lib/ice_cube/rules/secondly_rule.rb

@@ -1,7 +1,7 @@
 module IceCube
 
   class SecondlyRule < ValidatedRule
-    
+
     include Validations::SecondlyInterval
 
     def initialize(interval = 1)

data/lib/ice_cube/schedule.rb

@@ -7,27 +7,37 @@ module IceCube
     extend ::Deprecated
 
     # Get the start time
-    attr_accessor :start_time
+    attr_reader :start_time
     deprecated_alias :start_date, :start_time
-    deprecated_alias :start_date=, :start_time=
 
     # Get the duration
     attr_accessor :duration
 
     # Get the end time
-    attr_accessor :end_time
+    attr_reader :end_time
     deprecated_alias :end_date, :end_time
-    deprecated_alias :end_date=, :end_time=
 
     # Create a new schedule
     def initialize(start_time = nil, options = {})
-      @start_time = start_time || TimeUtil.now
-      @end_time = options[:end_time]
+      self.start_time = start_time || TimeUtil.now
+      self.end_time = options[:end_time]
       @duration = options[:duration]
       @all_recurrence_rules = []
       @all_exception_rules = []
     end
 
+    # Set start_time
+    def start_time=(start_time)
+      @start_time = TimeUtil.ensure_time start_time
+    end
+    deprecated_alias :start_date=, :start_time=
+
+    # Set end_time
+    def end_time=(end_time)
+      @end_time = TimeUtil.ensure_time end_time
+    end
+    deprecated_alias :end_date=, :end_time=
+
     # Add a recurrence time to the schedule
     def add_recurrence_time(time)
       return nil if time.nil?
@@ -145,17 +155,20 @@ module IceCube
     end
 
     # The next n occurrences after now
-    def next_occurrences(num, from = TimeUtil.now)
+    def next_occurrences(num, from = nil)
+      from ||= TimeUtil.now(@start_time.utc?)
       find_occurrences(from + 1, nil, num)
     end
 
     # The next occurrence after now (overridable)
-    def next_occurrence(from = TimeUtil.now)
+    def next_occurrence(from = nil)
+      from ||= TimeUtil.now(@start_time.utc?)
       find_occurrences(from + 1, nil, 1).first
     end
 
     # The remaining occurrences (same requirements as all_occurrences)
-    def remaining_occurrences(from = TimeUtil.now)
+    def remaining_occurrences(from = nil)
+      from ||= TimeUtil.now(@start_time.utc?)
       find_occurrences(from)
     end
 
@@ -179,6 +192,7 @@ module IceCube
 
     # Return a boolean indicating if an occurrence falls on a certain date
     def occurs_on?(date)
+      date = TimeUtil.ensure_date date
       begin_time = TimeUtil.beginning_of_date(date)
       closing_time = TimeUtil.end_of_date(date)
       occurs_between?(begin_time, closing_time)
@@ -199,6 +213,7 @@ module IceCube
     # @param [Time] closing_time - the last time to consider
     # @return [Boolean] whether or not the schedules conflict at all
     def conflicts_with?(other_schedule, closing_time = nil)
+      closing_time = TimeUtil.ensure_time closing_time
       unless terminating? || other_schedule.terminating? || closing_time
         raise ArgumentError.new 'At least one schedule must be terminating to use #conflicts_with?'
       end
@@ -302,7 +317,7 @@ module IceCube
       schedule = IceCube::Schedule.new TimeUtil.deserialize_time(data[:start_date])
       schedule.duration = data[:duration] if data[:duration]
       schedule.end_time = TimeUtil.deserialize_time(data[:end_time]) if data[:end_time]
-      data[:rrules] && data[:rrules].each { |h| schedule.rrule(IceCube::Rule.from_hash(h)) }  
+      data[:rrules] && data[:rrules].each { |h| schedule.rrule(IceCube::Rule.from_hash(h)) }
       data[:exrules] && data[:exrules].each { |h| schedule.exrule(IceCube::Rule.from_hash(h)) }
       data[:rtimes] && data[:rtimes].each do |t|
         schedule.add_recurrence_time TimeUtil.deserialize_time(t)
@@ -345,6 +360,8 @@ module IceCube
     # Find all of the occurrences for the schedule between opening_time
     # and closing_time
     def find_occurrences(opening_time, closing_time = nil, limit = nil, &block)
+      opening_time = TimeUtil.ensure_time opening_time
+      closing_time = TimeUtil.ensure_time closing_time
       reset
       answers = []
       opening_time = start_time if opening_time < start_time

data/lib/ice_cube/single_occurrence_rule.rb

@@ -5,7 +5,7 @@ module IceCube
     attr_reader :time
 
     def initialize(time)
-      @time = time
+      @time = TimeUtil.ensure_time time
     end
 
     # Always terminating

data/lib/ice_cube/time_util.rb

@@ -19,8 +19,27 @@ module IceCube
     }
 
     # Provides a Time.now without the usec
-    def self.now
-      Time.at Time.now.to_i
+    def self.now(utc = false)
+      time = Time.at(Time.now.to_i)
+      time = time.utc if utc
+      time
+    end
+
+    # Ensure that this is either nil, or a time
+    def self.ensure_time(time, date_eod = false)
+      case time
+      when DateTime then time.to_time
+      when Date then date_eod ? time.to_time.end_of_day : time.to_time
+      else time
+      end
+    end
+
+    # Ensure that this is either nil, or a date
+    def self.ensure_date(date)
+      case date
+      when Date then date
+      else date.to_time
+      end
     end
 
     # Serialize a time appropriate for storing

data/lib/ice_cube/validated_rule.rb

@@ -18,49 +18,21 @@ module IceCube
 
     # Compute the next time after (or including) the specified time in respect
     # to the given schedule
-    # NOTE: optimization target, sort the rules by their type, year first
-    # so we can make bigger jumps more often
     def next_time(time, schedule, closing_time)
-      loop do
-        break if @validations.all? do |name, vals|
-          # Execute each validation
-          res = vals.map do |validation|
-            validation.validate(time, schedule)
-          end
-          # If there is any nil, then we're set - otherwise choose the lowest
-          if res.any? { |r| r.nil? || r == 0 }
-            true
-          else
-            return nil if res.all? { |r| r === true } # allow quick escaping
-            res.reject! { |r| r.nil? || r == 0 || r === true }
-            if fwd = res.min
-              type = vals.first.type # get the jump type
-              dst_adjust = !vals.first.respond_to?(:dst_adjust?) || vals.first.dst_adjust?
-              wrapper = TimeUtil::TimeWrapper.new(time, dst_adjust)
-              wrapper.add(type, fwd)
-              wrapper.clear_below(type)
-              # Move over DST if blocked, no adjustments
-              if wrapper.to_time <= time
-                wrapper = TimeUtil::TimeWrapper.new(wrapper.to_time, false)
-                until wrapper.to_time > time
-                  wrapper.add(:min, 10) # smallest interval
-                end
-              end
-              # And then get the correct time out
-              time = wrapper.to_time
-            end
-            false
-          end
-        end
+      @time = time
+      @schedule = schedule
+
+      until finds_acceptable_time?
         # Prevent a non-matching infinite loop
-        return nil if closing_time && time > closing_time
+        return nil if closing_time && @time > closing_time
       end
+
       # NOTE Uses may be 1 higher than proper here since end_time isn't
       # validated in this class.  This is okay now, since we never expose it -
       # but if we ever do - we should check that above this line, and return
       # nil if end_time is past
-      @uses += 1 if time
-      time
+      @uses += 1 if @time
+      @time
     end
 
     def to_s
@@ -115,6 +87,55 @@ module IceCube
       end
     end
 
+    private
+
+    # NOTE: optimization target, sort the rules by their type, year first
+    # so we can make bigger jumps more often
+    def finds_acceptable_time?
+      @validations.all? do |name, validations_for_type|
+        validation_accepts_or_updates_time?(validations_for_type)
+      end
+    end
+
+    def validation_accepts_or_updates_time?(validations_for_type)
+      res = validated_results(validations_for_type)
+      # If there is any nil, then we're set - otherwise choose the lowest
+      if res.any? { |r| r.nil? || r == 0 }
+        true
+      else
+        return nil if res.all? { |r| r === true } # allow quick escaping
+        res.reject! { |r| r.nil? || r == 0 || r === true }
+        shift_time_by_validation(res, validations_for_type)
+        false
+      end
+    end
+
+    def validated_results(validations_for_type)
+      validations_for_type.map do |validation|
+        validation.validate(@time, @schedule)
+      end
+    end
+
+    def shift_time_by_validation(res, vals)
+      return unless res.min
+      type = vals.first.type # get the jump type
+      dst_adjust = !vals.first.respond_to?(:dst_adjust?) || vals.first.dst_adjust?
+      wrapper = TimeUtil::TimeWrapper.new(@time, dst_adjust)
+      wrapper.add(type, res.min)
+      wrapper.clear_below(type)
+
+      # Move over DST if blocked, no adjustments
+      if wrapper.to_time <= @time
+        wrapper = TimeUtil::TimeWrapper.new(wrapper.to_time, false)
+        until wrapper.to_time > @time
+          wrapper.add(:min, 10) # smallest interval
+        end
+      end
+
+      # And then get the correct time out
+      @time = wrapper.to_time
+    end
+
   end
 
 end

data/lib/ice_cube/validations/count.rb

@@ -45,7 +45,7 @@ module IceCube
       end
 
       StringBuilder.register_formatter(:count) do |segments|
-        count = segments.first 
+        count = segments.first
         "#{count} #{count == 1 ? 'time' : 'times'}"
       end
 

data/lib/ice_cube/validations/day.rb

@@ -3,7 +3,7 @@ require 'date'
 module IceCube
 
   module Validations::Day
-  
+
     def day(*days)
       days.each do |day|
         day = TimeUtil.symbol_to_day(day) if day.is_a?(Symbol)

data/lib/ice_cube/validations/hourly_interval.rb

@@ -42,7 +42,7 @@ module IceCube
 
       def validate(time, schedule)
         start_time = schedule.start_time
-        sec = (time.to_i - time.to_i % ONE_HOUR) - 
+        sec = (time.to_i - time.to_i % ONE_HOUR) -
           (start_time.to_i - start_time.to_i % ONE_HOUR)
         hours = sec / ONE_HOUR
         unless hours % interval == 0

data/lib/ice_cube/validations/lock.rb

@@ -23,11 +23,11 @@ module IceCube
       # If this number is positive, then follow our normal procedure
       if start > 0
         return start >= time.day ? start - time.day : days_in_this_month - time.day + start
-      end 
+      end
       # If the number is negative, and it resolved against the current month
       # puts it in the future, just return the difference
       days_in_this_month = TimeUtil.days_in_month(time)
-      start_one = days_in_this_month + start + 1 
+      start_one = days_in_this_month + start + 1
       if start_one >= time.day
         return start_one - time.day
       end

data/lib/ice_cube/validations/until.rb

@@ -11,6 +11,7 @@ module IceCube
     deprecated_alias :until_date, :until_time
 
     def until(time)
+      time = TimeUtil.ensure_time time, true
       @until = time
       replace_validations_for(:until, time.nil? ? nil : [Validation.new(time)])
       self

data/lib/ice_cube/validations/weekly_interval.rb

@@ -45,7 +45,7 @@ module IceCube
         st = schedule.start_time
         start_date = Date.new(st.year, st.month, st.day)
         weeks = (
-          (date - TimeUtil.normalize_weekday(date.wday, week_start)) - 
+          (date - TimeUtil.normalize_weekday(date.wday, week_start)) -
           (start_date - TimeUtil.normalize_weekday(start_date.wday, week_start))
         ) / 7
         unless weeks % interval == 0

data/lib/ice_cube/version.rb

@@ -1,5 +1,5 @@
 module IceCube
 
-  VERSION = '0.9.1'
+  VERSION = '0.9.2'
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ice_cube
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-19 00:00:00.000000000 Z
+date: 2012-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec