ice_cube 0.2.2

data/lib/ice_cube.rb

@@ -0,0 +1,44 @@
+require 'yaml.rb'
+require 'set.rb'
+
+require 'ice_cube/time_util'
+
+require 'ice_cube/validations/month_of_year'
+require 'ice_cube/validations/day_of_year'
+require 'ice_cube/validations/day_of_month'
+require 'ice_cube/validations/day_of_week'
+require 'ice_cube/validations/day'
+require 'ice_cube/validations/hour_of_day'
+require 'ice_cube/validations/minute_of_hour'
+require 'ice_cube/validations/second_of_minute'
+
+require 'ice_cube/rule'
+require 'ice_cube/schedule'
+require 'ice_cube/rule_occurrence'
+
+module IceCube
+  
+  autoload :DailyRule, 'ice_cube/rules/daily_rule'
+  autoload :WeeklyRule, 'ice_cube/rules/weekly_rule'
+  autoload :MonthlyRule, 'ice_cube/rules/monthly_rule'
+  autoload :YearlyRule, 'ice_cube/rules/yearly_rule'
+   
+  autoload :HourlyRule, 'ice_cube/rules/hourly_rule'
+  autoload :MinutelyRule, 'ice_cube/rules/minutely_rule'
+  autoload :SecondlyRule, 'ice_cube/rules/secondly_rule'
+
+  VERSION = '0.2.2'
+
+  ONE_DAY = 24 * 60 * 60
+  ONE_HOUR = 60 * 60
+  ONE_MINUTE = 60
+  ONE_SECOND = 1
+
+  ICAL_DAYS = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA']
+  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 }
+  
+  include TimeUtil
+
+end

data/lib/ice_cube/rule.rb

@@ -0,0 +1,169 @@
+module IceCube
+  
+  class Rule
+    
+    attr_reader :occurrence_count, :until_date
+
+    SuggestionTypes = []
+    include MonthOfYearValidation, DayOfYearValidation, DayOfMonthValidation, DayOfWeekValidation, DayValidation
+    include HourOfDayValidation, MinuteOfHourValidation, SecondOfMinuteValidation
+    
+    def to_hash
+      hash = Hash.new
+      hash[:rule_type] = self.class.name
+      hash[:interval] = @interval
+      hash[:until] = @until_date
+      hash[:count] = @occurrence_count
+      hash[:validations] = @validations
+      hash
+    end
+    
+    def self.from_hash(hash)
+      rule = hash[:rule_type].split('::').inject(Object) { |namespace, const_name| namespace.const_get(const_name) }.new(hash[:interval])
+      rule.count(hash[:count]) if hash[:count]
+      rule.until(hash[:until]) if hash[:until]
+      rule.validations = hash[:validations]
+      rule
+    end
+    
+    # create a new daily rule
+    def self.daily(interval = 1)
+      DailyRule.new(interval)
+    end
+
+    # create a new weekly rule
+    def self.weekly(interval = 1)
+      WeeklyRule.new(interval)
+    end
+
+    # create a new monthly rule
+    def self.monthly(interval = 1)
+      MonthlyRule.new(interval)
+    end
+
+    # create a new yearly rule
+    def self.yearly(interval = 1)
+      YearlyRule.new(interval)
+    end
+    
+    # create a new hourly rule
+    def self.hourly(interval = 1)
+      HourlyRule.new(interval)
+    end
+    
+    # create a new minutely rule
+    def self.minutely(interval = 1)
+      MinutelyRule.new(interval)
+    end
+    
+    # create a new secondly rule
+    def self.secondly(interval = 1)
+      SecondlyRule.new(interval)
+    end
+    
+    # Set the time when this rule will no longer be effective
+    def until(until_date)
+      raise ArgumentError.new('Cannot specify until and count on the same rule') if @count #as per rfc
+      raise ArgumentError.new('Argument must be a valid Time') unless until_date.class == Time
+      @until_date = until_date
+      self
+    end
+    
+    # set the number of occurrences after which this rule is no longer effective
+    def count(count)
+      raise ArgumentError.new('Argument must be a positive integer') unless Integer(count) && count >= 0
+      @occurrence_count = count
+      self
+    end
+    
+    def validate_single_date(date)
+      SuggestionTypes.all? do |s|
+        response = send("validate_#{s}", date)
+        response.nil? || response
+      end
+    end
+    
+    # The key - extremely educated guesses
+    # This spidering behavior will go through look for the next suggestion
+    # by constantly moving the farthest back value forward
+    def next_suggestion(date)
+      # get the next date recommendation set
+      suggestions = SuggestionTypes.map { |r| send("closest_#{r}", date) }
+      compact_suggestions = suggestions.compact
+      # find the next date to go to
+      if compact_suggestions.empty?
+        next_date = date
+        loop do
+          # keep going through rule suggestions
+          next_date = self.default_jump(next_date)
+          return next_date if validate_single_date(next_date)
+        end
+      else  
+        loop do
+          compact_suggestions = suggestions.compact
+          min_suggestion = compact_suggestions.min
+          # validate all against the minimum
+          return min_suggestion if validate_single_date(min_suggestion)
+          # move anything that is the minimum to its next closest
+          SuggestionTypes.each_with_index do |r, index|
+            suggestions[index] = send("closest_#{r}", min_suggestion) if min_suggestion == suggestions[index]
+          end
+        end
+      end
+    end
+    
+    def to_s
+      to_ical
+    end
+    
+    attr_accessor :validations
+    
+    private
+    
+    def adjust(goal, date)
+      return goal if goal.utc_offset == date.utc_offset
+      goal - goal.utc_offset + date.utc_offset
+    end
+    
+    #TODO - until date formatting is not iCalendar here
+    #get the icalendar representation of this rule logic
+    def to_ical_base
+      representation = ''
+      representation << ";INTERVAL=#{@interval}" if @interval > 1
+      representation << ';BYMONTH=' << @validations[:month_of_year].join(',') if @validations[:month_of_year]
+      representation << ';BYYEARDAY=' << @validations[:day_of_year].join(',') if @validations[:day_of_year]
+      representation << ';BYMONTHDAY=' << @validations[:day_of_month].join(',') if @validations[:day_of_month]
+      if @validations[:day] || @validations[:day_of_week]
+        representation << ';BYDAY='
+        days_dedup = @validations[:day].dup if @validations[:day]
+        #put days on the string, remove all occurrences in days from days_of_week
+        if days_dedup
+          @validations[:day_of_week].keys.each { |day| days_dedup.delete(day) } if @validations[:day_of_week]
+          representation << (days_dedup.map { |d| ICAL_DAYS[d]} ).join(',')
+        end 
+        representation << ',' if days_dedup && @validations[:day_of_week]
+        #put days_of_week on string representation
+        representation << @validations[:day_of_week].inject([]) do |day_rules, pair|
+          day, occ = *pair
+          day_rules.concat(occ.map {|v| v.to_s + ICAL_DAYS[day]})
+        end.flatten.join(',') if @validations[:day_of_week]
+      end
+      representation << ';BYHOUR=' << @validations[:hour_of_day].join(',') if @validations[:hour_of_day]
+      representation << ';BYMINUTE=' << @validations[:minute_of_hour].join(',') if @validations[:minute_of_hour]
+      representation << ';BYSECOND=' << @validations[:second_of_minute].join(',') if @validations[:second_of_minute]
+      representation << ";COUNT=#{@occurrence_count}" if @occurrence_count
+      representation << ";UNTIL=#{@until_date}" if @until_date
+      representation
+    end
+    
+    # Set the interval for the rule.  Depending on the type of rule,
+    # interval means every (n) weeks, months, etc. starting on the start_date's
+    def initialize(interval = 1)
+      throw ArgumentError.new('Interval must be > 0') unless interval > 0
+      @validations = {}
+      @interval = interval
+    end
+    
+  end
+
+end

data/lib/ice_cube/rule_occurrence.rb

@@ -0,0 +1,73 @@
+module IceCube
+  
+  class RuleOccurrence
+   
+    include Comparable
+    
+    #allow to be compared to dates
+    def <=>(other)
+      to_time <=> other
+    end
+    
+    def to_time
+      @date
+    end
+       
+    def all_occurrences
+      raise ArgumentError.new("Rule must specify either an until date or a count to use 'all_occurrences'") unless @rule.occurrence_count || @rule.until_date
+      find_occurrences { |roc| false }
+    end
+   
+    def upto(end_date)
+      find_occurrences { |roc| roc > end_date }
+    end
+
+    def first(n)
+      count = 0
+      find_occurrences { |roc| count += 1; count > n }
+    end
+
+    #get the next occurrence of this rule
+    def succ
+      return nil if @rule.occurrence_count && @index >= @rule.occurrence_count # count check
+      # get the next date to walk to
+      if @date.nil?
+        date = @start_date if @rule.validate_single_date(@start_date)
+        date = @rule.next_suggestion(@start_date) unless date
+      else
+        date = @rule.next_suggestion(@date)
+      end
+      #walk through all of the successive dates, looking for the next occurrence (interval-valid), then return it.
+      begin
+        return nil if @rule.until_date && date > @rule.until_date # until check
+        return RuleOccurrence.new(@rule, @start_date, date, @index + 1) if @rule.in_interval?(date, @start_date)
+      end while date = @rule.next_suggestion(date)
+    end
+    
+    attr_reader :rule
+   
+    private
+    
+    def find_occurrences
+      include_dates = []
+      roc = self
+      begin
+        break if roc.nil? #go until we run out of dates
+        next if roc.to_time.nil? #handle the case where start_date is not a valid occurrence
+        break if yield(roc) #recurrence condition
+        include_dates << roc.to_time
+      end while roc = roc.succ
+      include_dates
+    end
+      
+    def initialize(rule, start_date, date = nil, index = 0)
+      #set some variables
+      @rule = rule
+      @date = date
+      @start_date = start_date
+      @index = index
+    end
+      
+  end
+  
+end

data/lib/ice_cube/rules/daily_rule.rb

@@ -0,0 +1,31 @@
+module IceCube
+
+  class DailyRule < Rule
+
+    # Determine whether this rule occurs on a give date.
+    def in_interval?(date, start_date)
+      #make sure we're in a proper interval
+      day_count = ((date - start_date) / ONE_DAY).to_i
+      day_count % @interval == 0
+    end
+
+    def to_ical 
+      'FREQ=DAILY' << to_ical_base
+    end
+        
+    protected
+    
+    def default_jump(date)
+      goal = date + ONE_DAY * @interval
+      adjust(goal, date)
+    end
+     
+    private
+    
+    def initialize(interval)
+      super(interval)
+    end
+        
+  end
+
+end

data/lib/ice_cube/rules/hourly_rule.rb

@@ -0,0 +1,30 @@
+module IceCube
+
+  class HourlyRule < Rule
+
+    # Determine whether this rule occurs on a give date.
+    def in_interval?(date, start_date)
+      #make sure we're in a proper interval
+      day_count = ((date - start_date) / ONE_HOUR).to_i
+      day_count % @interval == 0
+    end
+
+    def to_ical 
+      'FREQ=HOURLY' << to_ical_base
+    end
+        
+    protected
+    
+    def default_jump(date)
+      date + ONE_HOUR * @interval
+    end
+        
+    private
+    
+    def initialize(interval)
+      super(interval)
+    end  
+      
+  end
+
+end

data/lib/ice_cube/rules/minutely_rule.rb

@@ -0,0 +1,30 @@
+module IceCube
+
+  class MinutelyRule < Rule
+
+    # Determine whether this rule occurs on a give date.
+    def in_interval?(date, start_date)
+      #make sure we're in a proper interval
+      day_count = ((date - start_date) / ONE_MINUTE).to_i
+      day_count % @interval == 0
+    end
+
+    def to_ical 
+      'FREQ=MINUTELY' << to_ical_base
+    end
+        
+    protected
+    
+    def default_jump(date)
+      date + ONE_MINUTE
+    end
+
+    private
+
+    def initialize(interval)
+      super(interval)
+    end
+        
+  end
+
+end

data/lib/ice_cube/rules/monthly_rule.rb

@@ -0,0 +1,36 @@
+module IceCube
+
+  class MonthlyRule < Rule
+
+    # Determine for a given date/start_date if this rule occurs or not.
+    # Month rules occur if we're in a valid interval
+    # and either (1) we're on a valid day of the week (ie: first sunday of the month)
+    # or we're on a valid day of the month (1, 15, -1)
+    # Note: Rollover is not implemented, so the 35th day of the month is invalid.
+    def in_interval?(date, start_date) 
+      #make sure we're in the proper interval
+      months_to_start_date = (date.month - start_date.month) + (date.year - start_date.year) * 12
+      months_to_start_date % @interval == 0
+    end
+    
+    def to_ical 
+      'FREQ=MONTHLY' << to_ical_base
+    end
+    
+    protected
+    
+    def default_jump(date)
+      date_type = date.utc? ? :utc : :local
+      next_month = date.month + @interval
+      Time.send(date_type, date.year + next_month / 12, (next_month - 1) % 12 + 1, date.day, date.hour, date.min, date.sec)
+    end
+ 
+    private
+
+    def initialize(interval)
+      super(interval)
+    end
+       
+  end
+
+end

data/lib/ice_cube/rules/secondly_rule.rb

@@ -0,0 +1,30 @@
+module IceCube
+
+  class SecondlyRule < Rule
+
+    # Determine whether this rule occurs on a give date.
+    def in_interval?(date, start_date)
+      #make sure we're in a proper interval
+      day_count = date - start_date
+      day_count % @interval == 0
+    end
+
+    def to_ical 
+      'FREQ=SECONDLY' << to_ical_base
+    end
+        
+    protected
+           
+    def default_jump(date)
+      date + 1
+    end
+
+    private
+
+    def initialize(interval)
+      super(interval)
+    end
+             
+  end
+
+end

data/lib/ice_cube/rules/weekly_rule.rb

@@ -0,0 +1,33 @@
+module IceCube
+
+  class WeeklyRule < Rule
+    
+    # Determine whether or not this rule occurs on a given date.
+    # Weekly rules occurs if we're in one of the interval weeks,
+    # and we're in a valid day of the week.
+    def in_interval?(date, start_date)
+      #make sure we're in the right interval
+      week_of_year = Date.civil(date.year, date.month, date.day).cweek
+      week_of_year % @interval == 0
+    end
+    
+    def to_ical 
+      'FREQ=WEEKLY' << to_ical_base
+    end
+    
+    protected
+    
+    def default_jump(date)
+      goal = date + 7 * ONE_DAY * @interval
+      adjust(goal, date)
+    end
+
+    private
+
+    def initialize(interval)
+      super(interval)
+    end
+     
+  end
+
+end

data/lib/ice_cube/rules/yearly_rule.rb

@@ -0,0 +1,36 @@
+module IceCube
+
+  class YearlyRule < Rule
+    
+    # Determine whether or not the rule, given a start_date,
+    # occurs on a given date.
+    # Yearly occurs if we're in a proper interval
+    # and either (1) we're on a day of the year, or (2) we're on a month of the year as specified
+    # Note: rollover dates don't work, so you can't ask for the 400th day of a year
+    # and expect to roll into the next year (this might be a possible direction in the future)
+    def in_interval?(date, start_date)
+      #make sure we're in the proper interval
+      (date.year - start_date.year) % @interval == 0
+    end
+    
+    def to_ical 
+      'FREQ=YEARLY' << to_ical_base
+    end
+    
+    protected
+    
+    # one year from now, the same month and day of the year
+    def default_jump(date)
+      date_type = date.utc? ? :utc : :local
+      Time.send(date_type, date.year + @interval, date.month, date.day, date.hour, date.min, date.sec)
+    end
+    
+    private
+
+    def initialize(interval)
+      super(interval)
+    end
+    
+  end
+    
+end

data/lib/ice_cube/schedule.rb

@@ -0,0 +1,108 @@
+module IceCube
+
+  class Schedule
+
+    def initialize(start_date)
+      @rrule_occurrence_heads = []
+      @exrule_occurrence_heads = []
+      @rdates = []
+      @exdates = []
+      @start_date = start_date
+    end
+
+    def to_hash
+      hash = Hash.new
+      hash[:start_date] = @start_date
+      hash[:rrules] = @rrule_occurrence_heads.map { |rr| rr.rule.to_hash }
+      hash[:exrules] = @exrule_occurrence_heads.map { |ex| ex.rule.to_hash }
+      hash[:rdates] = @rdates
+      hash[:exdates] = @exdates
+      hash
+    end
+    
+    def to_yaml
+      to_hash.to_yaml
+    end
+    
+    def self.from_hash(hash)
+      schedule = Schedule.new(hash[:start_date])
+      hash[:rrules].each { |rr| schedule.add_recurrence_rule Rule.from_hash(rr) }
+      hash[:exrules].each { |ex| schedule.add_exception_rule Rule.from_hash(ex) }
+      hash[:rdates].each { |rd| schedule.add_recurrence_date rd }
+      hash[:exdates].each { |ed| schedule.add_exception_date ed }
+      schedule
+    end
+    
+    def self.from_yaml(str)
+      from_hash(YAML::load(str))
+    end
+
+    # Determine whether a given date adheres to the ruleset of this schedule.
+    def occurs_on?(date)
+      dates = occurrences(date)
+      dates.last == date
+    end
+    
+    # Return all possible occurrences 
+    # In order to make this call, all rules in the schedule must have
+    # either an until date or an occurrence count
+    def all_occurrences
+      find_occurrences { |head| head.all_occurrences }
+    end
+    
+    # Find all occurrences until a certain date
+    def occurrences(end_date)
+      find_occurrences { |head| head.upto(end_date) }
+    end
+          
+    def first(n)
+      dates = find_occurrences { |head| head.first(n) }
+      dates.slice(0, n)
+    end
+             
+    # Add a rule of any type as an recurrence in this schedule
+    def add_recurrence_rule(rule)
+      raise ArgumentError.new('Argument must be a valid rule') unless rule.class < Rule
+      @rrule_occurrence_heads << RuleOccurrence.new(rule, @start_date)
+    end
+
+    # Add a rule of any type as an exception to this schedule
+    def add_exception_rule(rule)
+      raise ArgumentError.new('Argument must be a valid rule') unless rule.class < Rule
+      @exrule_occurrence_heads << RuleOccurrence.new(rule, @start_date)
+    end
+
+    # Add an individual date to this schedule
+    def add_recurrence_date(date)
+      raise ArgumentError.new('Argument must be a valid Time') unless date.class == Time
+      @rdates << date
+    end
+
+    # Add an individual date exception to this schedule
+    def add_exception_date(date)
+      raise ArgumentError.new('Argument must be a valid Time') unless date.class == Time
+      @exdates << date
+    end
+   
+    private
+    
+    # Find all occurrences (following rules and exceptions) from the schedule's start date to end_date.
+    # Use custom methods to say when to end
+    def find_occurrences
+      exclude_dates, include_dates = Set.new(@exdates), SortedSet.new(@rdates)
+      # walk through each rule, adding it to dates
+      @rrule_occurrence_heads.each do |rrule_occurrence_head|
+        include_dates.merge(yield(rrule_occurrence_head))
+      end
+      # walk through each exrule, removing it from dates
+      @exrule_occurrence_heads.each do |exrule_occurrence_head|
+        exclude_dates.merge(yield(exrule_occurrence_head))
+      end
+      #return a unique list of dates
+      include_dates.reject! { |date| exclude_dates.include?(date) }
+      include_dates.to_a
+    end
+   
+  end
+
+end

data/lib/ice_cube/time_util.rb

@@ -0,0 +1,18 @@
+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]
+
+  def self.is_leap?(date)
+    (date.year % 4 == 0 && date.year % 100 != 0) || (date.year % 400 == 0)
+  end
+
+  def self.days_in_year(date)
+    is_leap?(date) ? 366 : 365
+  end
+
+  def self.days_in_month(date)
+    is_leap?(date) ? LeapYearMonthDays[date.month - 1] : CommonYearMonthDays[date.month - 1]
+  end
+  
+end

data/lib/ice_cube/validations/day.rb

@@ -0,0 +1,36 @@
+module DayValidation
+  
+  def self.included(base)
+    base::SuggestionTypes << :day
+  end
+  
+  # Specify what days of the week this rule should occur on.
+  # ie: Schedule.weekly.day_of_week(:monday) would create a rule that
+  # occurs every monday.
+  def day(*days)
+    @validations[:day] ||= []
+    days.each do |day|
+      raise ArgumentError.new('Argument must be a valid day of the week') unless DAYS.has_key?(day)
+      @validations[:day] << DAYS[day]
+    end
+    self
+  end
+  
+  def validate_day(date)
+    return true if !@validations[:day] || @validations[:day].empty?
+    @validations[:day].include?(date.wday)
+  end
+  
+  def closest_day(date)
+    return nil if !@validations[:day] || @validations[:day].empty?
+    # turn days into distances
+    days = @validations[:day].map do |d| 
+      d > date.wday ? (d - date.wday) : (7 - date.wday + d)
+    end
+    days.compact!
+    # go to the closest distance away, the start of that day
+    goal = date + days.min * ONE_DAY
+    adjust(goal, date)
+  end
+  
+end

data/lib/ice_cube/validations/day_of_month.rb

@@ -0,0 +1,51 @@
+module DayOfMonthValidation
+    
+  def self.included(base)
+    base::SuggestionTypes << :day_of_month
+  end
+    
+  # Specify the days of the month that this rule should
+  # occur on.  ie: rule.day_of_month(1, -1) would mean that
+  # this rule should occur on the first and last day of every month.
+  def day_of_month(*days)
+    @validations[:day_of_month] ||= []
+    days.each do |day|
+      raise ArgumentError.new('Argument must be a valid date') if day.abs > 31 
+      raise ArgumentError.new('Argument must be non-zero') if day == 0
+      @validations[:day_of_month] << day
+    end
+    self
+  end
+    
+  def validate_day_of_month(date)
+    return true if !@validations[:day_of_month] || @validations[:day_of_month].empty?
+    @validations[:day_of_month].include?(date.mday) || @validations[:day_of_month].include?(date.mday - TimeUtil.days_in_month(date) - 1)
+  end
+  
+  def closest_day_of_month(date)
+    return nil if !@validations[:day_of_month] || @validations[:day_of_month].empty?
+    #get some variables we need
+    days_in_month = TimeUtil.days_in_month(date)
+    days_left_in_this_month = days_in_month - date.mday
+    next_month, next_year = date.month == 12 ? [1, date.year + 1] : [date.month + 1, date.year] #clean way to wrap over years
+    days_in_next_month = TimeUtil.days_in_month(Time.utc(next_year, next_month, 1))
+    # create a list of distances
+    distances = []
+    @validations[:day_of_month].each do |d|
+      if d > 0
+        distances << d - date.mday #today is 1, we want 20 (19)
+        distances << days_left_in_this_month + d #(364 + 20)
+      elsif d < 0
+        distances << (days_in_month + d + 1) - date.mday #today is 30, we want -1
+        distances << (days_in_next_month + d + 1) + days_left_in_this_month #today is 300, we want -70
+      end
+    end
+    #return the lowest distance
+    distances = distances.select { |d| d > 0 }
+    return nil if distances.empty?
+    # return the start of the proper day
+    goal = date + distances.min * ONE_DAY
+    adjust(goal, date)
+  end
+    
+end

data/lib/ice_cube/validations/day_of_week.rb

@@ -0,0 +1,41 @@
+module DayOfWeekValidation
+  
+  def self.included(base)
+    base::SuggestionTypes << :day_of_week
+  end
+  
+  # Specify the day(s) of the week that this rule should occur
+  # on.  ie: rule.day_of_week(:monday => [1, -1]) would mean
+  # that this rule should occur on the first and last mondays of each month.
+  def day_of_week(days)
+    @validations[:day_of_week] ||= {}
+    days.each do |day, occurrences|
+      raise ArgumentError.new('Argument must be a valid day') unless DAYS.has_key?(day)
+      @validations[:day_of_week][DAYS[day]] ||= []
+      @validations[:day_of_week][DAYS[day]].concat(occurrences)
+    end
+    self
+  end
+  
+  def validate_day_of_week(date)
+    # is it even one of the valid days?
+    return true if !@validations[:day_of_week] || @validations[:day_of_week].empty?
+    return false unless @validations[:day_of_week].has_key?(date.wday) #shortcut
+    # does this fall on one of the occurrences?
+    first_occurrence = ((7 - Time.utc(date.year, date.month, 1).wday) + date.wday) % 7 + 1 #day of first occurrence of a wday in a month
+    this_weekday_in_month_count = ((TimeUtil.days_in_month(date) - first_occurrence + 1) / 7.0).ceil #how many of these in the month
+    nth_occurrence_of_weekday = (date.mday - first_occurrence) / 7 + 1 #what occurrence of the weekday is +date+
+    @validations[:day_of_week][date.wday].include?(nth_occurrence_of_weekday) || @validations[:day_of_week][date.wday].include?(nth_occurrence_of_weekday - this_weekday_in_month_count - 1)
+  end
+  
+  #note - temporary implementation
+  def closest_day_of_week(date)
+    return nil if !@validations[:day_of_week] || @validations[:day_of_week].empty?
+    goal = date
+    while goal += ONE_DAY
+      test = adjust(goal, date)
+      return test if validate_day_of_week(test)
+    end
+  end
+  
+end

data/lib/ice_cube/validations/day_of_year.rb

@@ -0,0 +1,51 @@
+module DayOfYearValidation
+  
+  def self.included(base)
+    base::SuggestionTypes << :day_of_year
+  end
+  
+  # Specify what days of the year this rule applies to.
+  # ie: Schedule.yearly(2).days_of_year(17, -1) would create a
+  # rule which occurs every 17th and last day of every other year.
+  # Note: you cannot combine month_of_year and day_of_year in the same rule.
+  def day_of_year(*days)
+    @validations[:day_of_year] ||= []
+    days.each do |day|
+      raise ArgumentError.new('Argument must be a valid day') if day.abs > 366
+      raise ArgumentError.new('Argument must be non-zero') if day == 0
+      @validations[:day_of_year] << day
+    end
+    self
+  end
+  
+  def validate_day_of_year(date)
+    return true if !@validations[:day_of_year] || @validations[:day_of_year].empty?
+    @validations[:day_of_year].include?(date.yday) || @validations[:day_of_year].include?(date.yday - TimeUtil.days_in_year(date) - 1)
+  end
+  
+  def closest_day_of_year(date)
+    return nil if !@validations[:day_of_year] || @validations[:day_of_year].empty?
+    #get some variables we need
+    days_in_year = TimeUtil.days_in_year(date)
+    days_left_in_this_year = days_in_year - date.yday
+    days_in_next_year = TimeUtil.days_in_year(Time.utc(date.year + 1, 1, 1))
+    # create a list of distances
+    distances = []
+    @validations[:day_of_year].each do |d|
+      if d > 0
+        distances << d - date.yday #today is 1, we want 20 (19)
+        distances << days_left_in_this_year + d #(364 + 20)
+      elsif d < 0
+        distances << (days_in_year + d + 1) - date.yday #today is 300, we want -1
+        distances << (days_in_next_year + d + 1) + days_left_in_this_year #today is 300, we want -70
+      end
+    end
+    #return the lowest distance
+    distances = distances.select { |d| d > 0 }
+    return nil if distances.empty?
+    # return the start of the proper day
+    goal = date + distances.min * ONE_DAY
+    adjust(goal, date)
+  end
+  
+end

data/lib/ice_cube/validations/hour_of_day.rb

@@ -0,0 +1,35 @@
+module HourOfDayValidation
+  
+  def self.included(base)
+    base::SuggestionTypes << :hour_of_day
+  end
+  
+  def hour_of_day(*hours)
+    @validations[:hour_of_day] ||= []
+    hours.each do |hour| 
+      raise ArgumentError.new('Argument must be a valid hour') unless hour < 24 && hour >= 0
+      @validations[:hour_of_day] << hour
+    end
+    self
+  end
+  
+  def validate_hour_of_day(date)
+    return true if !@validations[:hour_of_day] || @validations[:hour_of_day].empty?
+    @validations[:hour_of_day].include?(date.hour)
+  end
+  
+  def closest_hour_of_day(date)
+    return nil if !@validations[:hour_of_day] || @validations[:hour_of_day].empty?
+    # turn hours into hour of day
+    # hour >= 24 should fall into the next day
+    hours = @validations[:hour_of_day].map do |h|
+      h > date.hour ? h - date.hour : 24 - date.hour + h
+    end
+    hours.compact!
+    # go to the closest distance away, the start of that hour
+    closest_hour = hours.min
+    goal = date + ONE_HOUR * closest_hour
+    adjust(goal, date)
+  end
+  
+end

data/lib/ice_cube/validations/minute_of_hour.rb

@@ -0,0 +1,35 @@
+module MinuteOfHourValidation
+  
+  def self.included(base)
+    base::SuggestionTypes << :minute_of_hour
+  end
+  
+  def minute_of_hour(*minutes)
+    @validations[:minute_of_hour] ||= []
+    minutes.each do |minute|
+      raise ArgumentError.new('Argument must be a valid minute') unless minute < 60 && minute >= 0
+      @validations[:minute_of_hour] << minute
+    end
+    self
+  end
+  
+  def validate_minute_of_hour(date)
+    return true if !@validations[:minute_of_hour] || @validations[:minute_of_hour].empty?
+    @validations[:minute_of_hour].include?(date.min)
+  end
+  
+  def closest_minute_of_hour(date)
+    return nil if !@validations[:minute_of_hour] || @validations[:minute_of_hour].empty?
+    # turn minutes into minutes of hour
+    # minute >= 60 should fall into the next hour
+    minutes = @validations[:minute_of_hour].map do |m|
+      m > date.min ? m - date.min : 60 - date.min + m
+    end
+    minutes.compact!
+    # go to the closest distance away, the beginning of that minute
+    closest_minute = minutes.min
+    goal = date + closest_minute * ONE_MINUTE
+    adjust(goal, date)
+  end
+  
+end

data/lib/ice_cube/validations/month_of_year.rb

@@ -0,0 +1,39 @@
+module MonthOfYearValidation
+  
+  def self.included(base)
+    base::SuggestionTypes << :month_of_year
+  end
+  
+  # Specify what months of the year this rule applies to.  
+  # ie: Schedule.yearly(2).month_of_year(:january, :march) would create a
+  # rule which occurs every january and march, every other year
+  # Note: you cannot combine day_of_year and month_of_year in the same rule.
+  def month_of_year(*months)
+    @validations[:month_of_year] ||= []
+    months.each do |month|
+      raise ArgumentError.new('Argument must be a valid month') unless MONTHS.has_key?(month)
+      @validations[:month_of_year] << MONTHS[month]
+    end
+    self
+  end
+  
+  def validate_month_of_year(date)
+    return true if !@validations[:month_of_year] || @validations[:month_of_year].empty?
+    @validations[:month_of_year].include?(date.month)
+  end
+  
+  def closest_month_of_year(date)
+    return nil if !@validations[:month_of_year] || @validations[:month_of_year].empty?
+    # turn months into month of year
+    # month > 12 should fall into the next year
+    months = @validations[:month_of_year].map do |m|
+      m > date.month ? m - date.month : 12 - date.month + m
+    end
+    months.compact!
+    # go to the closest distance away
+    goal = date
+    months.min.times { goal += TimeUtil.days_in_month(goal) * ONE_DAY }
+    adjust(goal, date)
+  end
+  
+end

data/lib/ice_cube/validations/second_of_minute.rb

@@ -0,0 +1,35 @@
+module SecondOfMinuteValidation
+  
+  def self.included(base)
+    base::SuggestionTypes << :second_of_minute
+  end
+  
+  def second_of_minute(*seconds)
+    @validations[:second_of_minute] ||= []
+    seconds.each do |second|
+      raise ArgumentError.new('Argument must be a valid second') unless second < 60 && second >= 0
+      @validations[:second_of_minute] << second
+    end
+    self
+  end
+  
+  def validate_second_of_minute(date)
+    return true if !@validations[:second_of_minute] || @validations[:second_of_minute].empty?
+    @validations[:second_of_minute].include?(date.sec)
+  end
+  
+  def closest_second_of_minute(date)
+    return nil if !@validations[:second_of_minute] || @validations[:second_of_minute].empty?
+    # turn seconds into seconds of minute
+    # second >= 60 should fall into the next minute
+    seconds = @validations[:second_of_minute].map do |s|
+      s > date.sec ? s - date.sec : 60 - date.sec + s
+    end
+    seconds.compact!
+    # go to the closest distance away
+    closest_second = seconds.min
+    goal = date + closest_second
+    adjust(goal, date)
+  end
+  
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: ice_cube
+version: !ruby/object:Gem::Version 
+  version: 0.2.2
+platform: ruby
+authors: 
+- John Crepezzi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-01 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: ice_cube is a recurring date library for Ruby.  It allows for quick, programatic expansion of recurring date rules.
+email: john@crepezzi.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/ice_cube/rule.rb
+- lib/ice_cube/rule_occurrence.rb
+- lib/ice_cube/rules/daily_rule.rb
+- lib/ice_cube/rules/hourly_rule.rb
+- lib/ice_cube/rules/minutely_rule.rb
+- lib/ice_cube/rules/monthly_rule.rb
+- lib/ice_cube/rules/secondly_rule.rb
+- lib/ice_cube/rules/weekly_rule.rb
+- lib/ice_cube/rules/yearly_rule.rb
+- lib/ice_cube/schedule.rb
+- lib/ice_cube/time_util.rb
+- lib/ice_cube/validations/day.rb
+- lib/ice_cube/validations/day_of_month.rb
+- lib/ice_cube/validations/day_of_week.rb
+- lib/ice_cube/validations/day_of_year.rb
+- lib/ice_cube/validations/hour_of_day.rb
+- lib/ice_cube/validations/minute_of_hour.rb
+- lib/ice_cube/validations/month_of_year.rb
+- lib/ice_cube/validations/second_of_minute.rb
+- lib/ice_cube.rb
+has_rdoc: true
+homepage: http://github.com/seejohnrun/ice_cube
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Ruby Date Recurrence Library
+test_files: []
+