ice_cube 0.6.14 → 0.7.0

data/lib/ice_cube/single_occurrence_rule.rb

@@ -0,0 +1,28 @@
+module IceCube
+
+  class SingleOccurrenceRule < Rule
+
+    attr_reader :time
+
+    def initialize(time)
+      @time = time
+    end
+
+    # Always terminating
+    def terminating?
+      true
+    end
+
+    def next_time(t, schedule, closing_time)
+      unless closing_time && closing_time < t
+        time if time >= t
+      end
+    end
+
+    def to_hash
+      { :time => time }
+    end
+
+  end
+
+end

data/lib/ice_cube/time_util.rb

@@ -1,101 +1,227 @@
+require 'date'
+
 module IceCube
 
   module TimeUtil
-    
-    LeapYearMonthDays	=	[31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
-    CommonYearMonthDays	=	[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
-    
+
+    LEAP_YEAR_MONTH_DAYS = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+    COMMON_YEAR_MONTH_DAYS = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+
+    DAYS = {
+      :sunday => 0, :monday => 1, :tuesday => 2, :wednesday => 3,
+      :thursday => 4, :friday => 5, :saturday => 6
+    }
+
+    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
+    }
+
+    # Serialize a time appropriate for storing
     def self.serialize_time(time)
-      if time.is_a?(ActiveSupport::TimeWithZone)
-        { :time => time, :zone => time.time_zone.name }
+      if defined?(:ActiveSupport) && const_defined?(:ActiveSupport) && time.is_a?(ActiveSupport::TimeWithZone)
+        { :time => time.utc, :zone => time.time_zone.name }
       elsif time.is_a?(Time)
         time
       end
     end
-    
-    def self.deserialize_time(time_or_hash) 
-      return time_or_hash if time_or_hash.is_a?(Time) # for backward-compat
-      if time_or_hash.is_a?(Hash)
+
+    # Deserialize a time serialized with serialize_time
+    def self.deserialize_time(time_or_hash)
+      if time_or_hash.is_a?(Time)
+        time_or_hash
+      elsif time_or_hash.is_a?(Hash)
         time_or_hash[:time].in_time_zone(time_or_hash[:zone])
       end
     end
 
-    # TODO can we improve this more?
-    def self.date_in_n_months(date, month_distance)
-      
-      next_mark = date
-      days_in_month_of_next_mark = days_in_month(next_mark)
-      
-      month_distance.times do
-        
-        prev_mark = next_mark
-        next_mark += days_in_month_of_next_mark * IceCube::ONE_DAY
-        
-        # only moving one day at a time, so this suffices
-        months_covered = next_mark.month - prev_mark.month
-        months_covered += 12 if months_covered < 0
-        
-        # step back to the end of the previous month of months_covered went too far
-        if months_covered == 2
-          next_mark -= next_mark.mday * IceCube::ONE_DAY
-        end
-        
-        days_in_month_of_next_mark = days_in_month(next_mark)
-        next_mark = adjust(next_mark, prev_mark)
-        
-      end
-      
-      # at the end, there's a chance we're not on the correct day,
-      # but if we're not - we will always be behind it in the correct month
-      # if there exists no proper day in the month for us, return nil - otherwise, return that date
-      
-      if days_in_month_of_next_mark >= date.mday
-        next_mark += (date.mday - next_mark.mday) * IceCube::ONE_DAY
-      end
-      
+    # Get the beginning of a date
+    def self.beginning_of_date(date)
+      date.respond_to?(:beginning_of_day) ?
+        date.beginning_of_day :
+        Time.local(date.year, date.month, date.day, 0, 0, 0)
     end
-    
-    def self.adjust(goal, date)
-      return goal if goal.utc_offset == date.utc_offset
-      goal - goal.utc_offset + date.utc_offset
+
+    # Get the end of a date
+    def self.end_of_date(date)
+      date.respond_to?(:end_of_day) ?
+        date.end_of_day :
+        Time.local(date.year, date.month, date.day, 23, 59, 59)
     end
-    
-    def self.is_leap?(year)
-      (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)
+
+    # Convert a symbol to a numeric month
+    def self.symbol_to_month(sym)
+      month = MONTHS[sym]
+      raise "No such month: #{sym}" unless month
+      month
     end
-    
-    def self.days_in_year(date)
-      is_leap?(date.year) ? 366 : 365
+
+    # Convert a symbol to a numeric day
+    def self.symbol_to_day(sym)
+      day = DAYS[sym]
+      raise "No such day: #{sym}" unless day
+      day
     end
-    
-    def self.days_in_month(date)
-      is_leap?(date.year) ? LeapYearMonthDays[date.month - 1] : CommonYearMonthDays[date.month - 1]
+
+    # Return the count of the number of times wday appears in the month,
+    # and which of those time falls on
+    def self.which_occurrence_in_month(time, wday)
+      first_occurrence = ((7 - Time.utc(time.year, time.month, 1).wday) + time.wday) % 7 + 1
+      this_weekday_in_month_count = ((days_in_month(time) - first_occurrence + 1) / 7.0).ceil
+      nth_occurrence_of_weekday = (time.mday - first_occurrence) / 7 + 1
+      [nth_occurrence_of_weekday, this_weekday_in_month_count]
     end
-    
-    def self.ical_utc_format(time)
-      time = time.dup.utc
-      "#{time.strftime('%Y%m%dT%H%M%SZ')}" # utc time
+
+    # Get the days in the month for +time
+    def self.days_in_month(time)
+      days_in_month_year(time.month, time.year)
     end
- 
-    def self.ical_format(time, force_utc)
-      time = time.dup.utc if force_utc
-      if time.utc?
-        ":#{time.strftime('%Y%m%dT%H%M%SZ')}" # utc time
-      else
-        ";TZID=#{time.strftime('%Z:%Y%m%dT%H%M%S')}" # local time specified
+
+    def self.days_in_next_month(time)
+      # Get the next month
+      year = time.year
+      month = time.month + 1
+      if month > 12
+        month %= 12
+        year += 1
       end
+      # And then determine
+      days_in_month_year(month, year)
     end
-    
-    def self.ical_duration(duration)
-      hours = duration / 3600; duration %= 3600
-      minutes = duration / 60; duration %= 60
-      repr = ''
-      repr << "#{hours}H" if hours > 0
-      repr << "#{minutes}M" if minutes > 0
-      repr << "#{duration}S" if duration > 0
-      "PT#{repr}"
+
+    def self.days_in_month_year(month, year)
+      is_leap?(year) ? LEAP_YEAR_MONTH_DAYS[month - 1] : COMMON_YEAR_MONTH_DAYS[month - 1]
     end
     
+    # Number of days in a year
+    def self.days_in_year(time)
+      is_leap?(time.year) ? 366 : 365
+    end
+
+    # Number of days to n years
+    def self.days_in_n_years(time, year_distance)
+      sum = 0
+      wrapper = TimeWrapper.new(time)
+      year_distance.times do
+        diy = days_in_year(wrapper.to_time)
+        sum += diy
+        wrapper.add(:day, diy)
+      end
+      sum
+    end
+
+    # The number of days in n months
+    def self.days_in_n_months(time, month_distance)
+      # move to a safe spot in the month to make this computation
+      desired_day = time.day
+      time -= IceCube::ONE_DAY * (time.day - 27) if time.day >= 28
+      # move n months ahead
+      sum = 0
+      wrapper = TimeWrapper.new(time)
+      month_distance.times do
+        dim = days_in_month(wrapper.to_time)
+        sum += dim
+        wrapper.add(:day, dim)
+      end
+      # now we can move to the desired day
+      dim = days_in_month(wrapper.to_time)
+      if desired_day > dim
+        sum -= desired_day - dim
+      end
+      sum
+    end
+
+    # Given a year, return a boolean indicating whether it is
+    # a leap year or not
+    def self.is_leap?(year)
+      (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)
+    end
+
+    # A utility class for safely moving time around
+    class TimeWrapper
+
+      def initialize(time, dst_adjust = true)
+        @dst_adjust = dst_adjust
+        @time = time
+      end
+
+      # Get the wrapper time back
+      def to_time
+        @time
+      end
+
+      # DST-safely add an interval of time to the wrapped time
+      def add(type, val)
+        type = :day if type == :wday
+        adjust do
+          @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
+        end
+      end
+
+      # Clear everything below a certain type
+      CLEAR_ORDER = [:sec, :min, :hour, :day, :month, :year]
+      def clear_below(type)
+        type = :day if type == :wday
+        CLEAR_ORDER.each do |ptype|
+          break if ptype == type
+          adjust do
+            send(:"clear_#{ptype}")
+          end
+        end
+      end
+
+      private
+
+      def adjust(&block)
+        if @dst_adjust
+          off = @time.utc_offset
+          yield
+          diff = off - @time.utc_offset
+          @time += diff if diff != 0
+        else
+          yield
+        end
+      end
+ 
+      def clear_sec
+        @time -= @time.sec
+      end
+
+      def clear_min
+        @time -= (@time.min * ONE_MINUTE)
+      end
+
+      def clear_hour
+        @time -= (@time.hour * ONE_HOUR)
+      end
+
+      # Move to the first of the month, 0 hours
+      def clear_day
+        @time -= (@time.day - 1) * IceCube::ONE_DAY
+      end
+
+      # Clear to january 1st
+      def clear_month
+        @time -= ONE_DAY
+        until @time.month == 12
+          @time -= TimeUtil.days_in_month(@time) * ONE_DAY
+        end
+        @time += ONE_DAY
+      end
+
+      def clear_year
+      end
+
+    end
+
   end
 
 end

data/lib/ice_cube/validated_rule.rb

@@ -0,0 +1,107 @@
+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
+
+    # 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)
+              time = wrapper.to_time
+            end
+            false
+          end
+        end
+        # Prevent a non-matching infinite loop
+        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
+    end 
+
+    def to_s
+      builder = StringBuilder.new
+      @validations.each do |name, validations|
+        validations.each do |validation|
+          validation.build_s(builder)
+        end
+      end
+      builder.to_s
+    end
+
+    def to_hash
+      builder = HashBuilder.new(self)
+      @validations.each do |name, validations|
+        validations.each do |validation|
+          validation.build_hash(builder)
+        end
+      end
+      builder.to_hash
+    end
+
+    def to_ical
+      builder = IcalBuilder.new
+      @validations.each do |name, validations|
+        validations.each do |validation|
+          validation.build_ical(builder)
+        end
+      end
+      builder.to_s
+    end
+
+    # Get the collection that contains validations of a certain type
+    def validations_for(key)
+      @validations ||= {}
+      @validations[key] ||= []
+    end
+
+    # Fully replace validations
+    def replace_validations_for(key, arr)
+      @validations[key] = arr
+    end
+
+    # Remove the specified base validations
+    def clobber_base_validations(*types)
+      types.each do |type|
+        @validations.delete(:"base_#{type}")
+      end
+    end
+
+  end
+
+end

data/lib/ice_cube/validations/count.rb

@@ -0,0 +1,56 @@
+module IceCube
+
+  module Validations::Count
+
+    # accessor
+    def occurrence_count
+      @count
+    end
+
+    def count(max)
+      @count = max
+      replace_validations_for(:count, [Validation.new(max, self)]) # replace
+      self
+    end
+
+    class Validation
+
+      attr_reader :rule, :count
+
+      def initialize(count, rule)
+        @count = count
+        @rule = rule
+      end
+
+      def type
+        :dealbreaker
+      end
+
+      def validate(time, schedule)
+        if rule.uses && rule.uses >= count
+          raise CountExceeded
+        end
+      end
+
+      def build_s(builder)
+        builder.piece(:count) << count
+      end
+
+      def build_hash(builder)
+        builder[:count] = count
+      end
+
+      def build_ical(builder)
+        builder['COUNT'] << count
+      end
+
+      StringBuilder.register_formatter(:count) do |segments|
+        count = segments.first 
+        "#{count} #{count == 1 ? 'time' : 'times'}"
+      end
+
+    end
+
+  end
+
+end