ice_cube_conrad 0.8.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

@@ -0,0 +1,250 @@
+require 'date'
+
+module IceCube
+
+  module TimeUtil
+
+    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
+    }
+
+    ICAL_DAYS = { 
+      '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
+    }
+
+    # Serialize a time appropriate for storing
+    def self.serialize_time(time)
+      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
+
+    # 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
+
+    # 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
+
+    # 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
+
+    # 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
+
+    # 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.ical_day_to_symbol(str)
+      day = ICAL_DAYS[str]
+      raise "No such day: #{str}" if day.nil?
+      day
+    end
+
+    # Convert a symbol to an ical day (SU, MO)
+    def self.week_start(sym)
+      raise "No such day: #{sym}" 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_weekday(daynum, week_start)
+      (daynum - symbol_to_day(week_start)) % 7
+    end
+
+    # 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
+
+    # 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.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.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,108 @@
+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

data/lib/ice_cube/validations/daily_interval.rb

@@ -0,0 +1,55 @@
+module IceCube
+
+  module Validations::DailyInterval
+
+    # Add a new interval validation
+    def interval(interval)
+      validations_for(:interval) << Validation.new(interval)
+      clobber_base_validations(:wday, :day)
+      self
+    end
+
+    # A validation for checking to make sure that a time
+    # is inside of a certain DailyInterval
+    class Validation
+
+      attr_reader :interval
+
+      def initialize(interval)
+        @interval = interval
+      end
+
+      def build_s(builder)
+        builder.base = interval == 1 ? 'Daily' : "Every #{interval} days"
+      end
+
+      def build_hash(builder)
+        builder[:interval] = interval
+      end
+
+      def build_ical(builder)
+        builder['FREQ'] << 'DAILY'
+        unless interval == 1
+          builder['INTERVAL'] << interval
+        end
+      end
+
+      def type
+        :day
+      end
+
+      def validate(time, schedule)
+        raise ZeroInterval if interval == 0
+        time_date = Date.new(time.year, time.month, time.day)
+        start_date = Date.new(schedule.start_time.year, schedule.start_time.month, schedule.start_time.day)
+        days = time_date - start_date
+        unless days % interval === 0
+          interval - (days % interval)
+        end
+      end
+
+    end
+
+  end
+
+end