ice_cube_chosko 0.1.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 = TimeUtil.ensure_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.to_i >= t.to_i
+      end
+    end
+
+    def to_hash
+      { :time => time }
+    end
+
+  end
+
+end

data/lib/ice_cube/time_util.rb

@@ -0,0 +1,328 @@
+require 'date'
+require 'time'
+
+module IceCube
+  module TimeUtil
+
+    extend Deprecated
+
+    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
+    }
+
+    CLOCK_VALUES = [:year, :month, :day, :hour, :min, :sec]
+
+    # Provides a Time.now without the usec, in the reference zone or utc offset
+    def self.now(reference=Time.now)
+      match_zone(Time.at(Time.now.to_i), reference)
+    end
+
+    def self.build_in_zone(args, reference)
+      if reference.respond_to?(:time_zone)
+        reference.time_zone.local(*args)
+      elsif reference.utc?
+        Time.utc(*args)
+      elsif reference.zone
+        Time.local(*args)
+      else
+        Time.new(*args << reference.utc_offset)
+      end
+    end
+
+    def self.match_zone(input_time, reference)
+      return unless time = ensure_time(input_time)
+      time = if reference.respond_to? :time_zone
+               time.in_time_zone(reference.time_zone)
+             else
+               if reference.utc?
+                 time.utc
+               elsif reference.zone
+                 time.getlocal
+               else
+                 time.getlocal(reference.utc_offset)
+               end
+             end
+      (Date === input_time) ? beginning_of_date(time, reference) : time
+    end
+
+    # Ensure that this is either nil, or a time
+    def self.ensure_time(time, date_eod = false)
+      case time
+      when DateTime
+        warn "IceCube: DateTime support is deprecated (please use Time) at: #{ caller[2] }"
+        Time.local(time.year, time.month, time.day, time.hour, time.min, time.sec)
+      when Date
+        date_eod ? end_of_date(time) : 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
+        return Date.new(date.year, date.month, date.day)
+      end
+    end
+
+    # Serialize a time appropriate for storing
+    def self.serialize_time(time)
+      if time.respond_to?(:time_zone)
+        {:time => time.utc, :zone => time.time_zone.name}
+      elsif time.is_a?(Time)
+        time
+      end
+    end
+
+    # Deserialize a time serialized with serialize_time or in ISO8601 string format
+    def self.deserialize_time(time_or_hash)
+      case time_or_hash
+      when Time
+        time_or_hash
+      when Hash
+        hash = FlexibleHash.new(time_or_hash)
+        hash[:time].in_time_zone(hash[:zone])
+      when String
+        Time.parse(time_or_hash)
+      end
+    end
+
+    # Check the deserialized time offset string against actual local time
+    # offset to try and preserve the original offset for plain Ruby Time. If
+    # the offset is the same as local we can assume the same original zone and
+    # keep it.  If it was serialized with a different offset than local TZ it
+    # will lose the zone and not support DST.
+    def self.restore_deserialized_offset(time, orig_offset_str)
+      return time if time.respond_to?(:time_zone) ||
+                     time.getlocal(orig_offset_str).utc_offset == time.utc_offset
+      warn "IceCube: parsed Time from nonlocal TZ. Use ActiveSupport to fix DST at: #{ caller[0] }"
+      time.localtime(orig_offset_str)
+    end
+
+    # Get the beginning of a date
+    def self.beginning_of_date(date, reference=Time.now)
+      build_in_zone([date.year, date.month, date.day, 0, 0, 0], reference)
+    end
+
+    # Get the end of a date
+    def self.end_of_date(date, reference=Time.now)
+      build_in_zone([date.year, date.month, date.day, 23, 59, 59], reference)
+    end
+
+    # Convert a symbol to a numeric month
+    def self.sym_to_month(sym)
+      MONTHS.fetch(sym) do |k|
+        MONTHS.values.detect { |i| i.to_s == k.to_s } or
+        raise ArgumentError, "Expecting Fixnum or Symbol value for month. " \
+                             "No such month: #{k.inspect}"
+      end
+    end
+    deprecated_alias :symbol_to_month, :sym_to_month
+
+    # Convert a symbol to a wday number
+    def self.sym_to_wday(sym)
+      DAYS.fetch(sym) do |k|
+        DAYS.values.detect { |i| i.to_s == k.to_s } or
+        raise ArgumentError, "Expecting Fixnum or Symbol value for weekday. " \
+                             "No such weekday: #{k.inspect}"
+      end
+    end
+    deprecated_alias :symbol_to_day, :sym_to_wday
+
+    # Convert wday number to day symbol
+    def self.wday_to_sym(wday)
+      return sym = wday if DAYS.keys.include? wday
+      DAYS.invert.fetch(wday) do |i|
+        raise ArgumentError, "Expecting Fixnum 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
+    end
+    deprecated_alias :normalize_weekday, :normalize_wday
+
+    def self.ical_day_to_symbol(str)
+      day = ICAL_DAYS[str]
+      raise ArgumentError, "Invalid day: #{str}" if day.nil?
+      day
+    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)
+      date = Date.new(time.year, time.month, 1)
+      ((date >> 1) - date).to_i
+    end
+
+    # Get the days in the following month for +time
+    def self.days_in_next_month(time)
+      date = Date.new(time.year, time.month, 1) >> 1
+      ((date >> 1) - date).to_i
+    end
+
+    # Count the number of days to the same day of the next month without
+    # overflowing shorter months
+    def self.days_to_next_month(time)
+      date = Date.new(time.year, time.month, time.day)
+      ((date >> 1) - date).to_i
+    end
+
+    # Get a day of the month in the month of a given time without overflowing
+    # into the next month. Accepts days from positive (start of month forward) or
+    # negative (from end of month)
+    def self.day_of_month(value, date)
+      if value.to_i > 0
+        [value, days_in_month(date)].min
+      else
+        [1 + days_in_month(date) + value, 1].max
+      end
+    end
+
+    # Number of days in a year
+    def self.days_in_year(time)
+      date = Date.new(time.year, 1, 1)
+      ((date >> 12) - date).to_i
+    end
+
+    # Number of days to n years
+    def self.days_in_n_years(time, year_distance)
+      date = Date.new(time.year, time.month, time.day)
+      ((date >> year_distance * 12) - date).to_i
+    end
+
+    # The number of days in n months
+    def self.days_in_n_months(time, month_distance)
+      date = Date.new(time.year, time.month, time.day)
+      ((date >> month_distance) - date).to_i
+    end
+
+    def self.dst_change(time)
+      one_hour_ago = time - ONE_HOUR
+      if time.dst? ^ one_hour_ago.dst?
+        (time.utc_offset - one_hour_ago.utc_offset) / ONE_HOUR
+      end
+    end
+
+    def self.same_clock?(t1, t2)
+      CLOCK_VALUES.all? { |i| t1.send(i) == t2.send(i) }
+    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.sec > 0 ? @time -= @time.sec : @time
+      end
+
+      def clear_min
+        @time.min > 0 ? @time -= (@time.min * ONE_MINUTE) : @time
+      end
+
+      def clear_hour
+        @time.hour > 0 ? @time -= (@time.hour * ONE_HOUR) : @time
+      end
+
+      # Move to the first of the month, 0 hours
+      def clear_day
+        @time.day > 1 ? @time -= (@time.day - 1) * ONE_DAY : @time
+      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
+        @time
+      end
+
+    end
+
+  end
+end

data/lib/ice_cube/validated_rule.rb

@@ -0,0 +1,184 @@
+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
+
+    # Validations ordered for efficiency in sequence of:
+    # * descending intervals
+    # * boundary limits
+    # * base values by cardinality (n = 60, 60, 31, 24, 12, 7)
+    # * locks by cardinality (n = 365, 60, 60, 31, 24, 12, 7)
+    # * interval multiplier
+    VALIDATION_ORDER = [
+      :year, :month, :day, :wday, :hour, :min, :sec, :count, :until,
+      :base_sec, :base_min, :base_day, :base_hour, :base_month, :base_wday,
+      :day_of_year, :second_of_minute, :minute_of_hour, :day_of_month,
+      :hour_of_day, :month_of_year, :day_of_week,
+      :interval
+    ]
+
+    attr_reader :validations
+
+    def initialize(interval = 1, *)
+      @validations = Hash.new
+    end
+
+    def base_interval_validation
+      @validations[:interval].first
+    end
+
+    def other_interval_validations
+      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 schedule
+    def next_time(time, schedule, closing_time)
+      @time = time
+      @schedule = schedule
+
+      return nil unless find_acceptable_time_before(closing_time)
+
+      @uses += 1 if @time
+      @time
+    end
+
+    def skipped_for_dst
+      @uses -= 1 if @uses > 0
+    end
+
+    def dst_adjust?
+      @validations[:interval].any? &:dst_adjust?
+    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[key] ||= []
+    end
+
+    # Fully replace validations
+    def replace_validations_for(key, arr)
+      if arr.nil?
+        @validations.delete(key)
+      else
+        @validations[key] = arr
+      end
+    end
+
+    # Remove the specified base validations
+    def clobber_base_validations(*types)
+      types.each do |type|
+        @validations.delete(:"base_#{type}")
+      end
+    end
+
+    private
+
+    def normalized_interval(interval)
+      int = interval.to_i
+      raise ArgumentError, "'#{interval}' is not a valid input for interval. Please pass an integer." unless int > 0
+      int
+    end
+
+    def finds_acceptable_time?
+      validation_names.all? do |type|
+        validation_accepts_or_updates_time?(@validations[type])
+      end
+    end
+
+    def find_acceptable_time_before(boundary)
+      until finds_acceptable_time?
+        return false if past_closing_time?(boundary)
+      end
+      true
+    end
+
+    # Returns true if all validations for the current rule match
+    # otherwise false and shifts to the first (largest) unmatched offset
+    #
+    def validation_accepts_or_updates_time?(validations_for_type)
+      res = validations_for_type.each_with_object([]) do |validation, offsets|
+        r = validation.validate(@time, @schedule)
+        return true if r.nil? || r == 0
+        offsets << r
+      end
+      shift_time_by_validation(res, validations_for_type.first)
+      false
+    end
+
+    def shift_time_by_validation(res, validation)
+      return unless (interval = res.min)
+      wrapper = TimeUtil::TimeWrapper.new(@time, validation.dst_adjust?)
+      wrapper.add(validation.type, interval)
+      wrapper.clear_below(validation.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
+
+    def past_closing_time?(closing_time)
+      closing_time && @time > closing_time
+    end
+
+    def validation_names
+      VALIDATION_ORDER & @validations.keys
+    end
+
+  end
+
+end