ice_cube 0.2.7 → 0.2.8

data/lib/ice_cube.rb

@@ -1,17 +1,11 @@
 require 'yaml.rb'
 require 'set.rb'
+require 'date'
 
 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/validation'
+require 'ice_cube/validation_types'
 require 'ice_cube/rule'
 require 'ice_cube/schedule'
 require 'ice_cube/rule_occurrence'
@@ -27,6 +21,15 @@ module IceCube
   autoload :MinutelyRule, 'ice_cube/rules/minutely_rule'
   autoload :SecondlyRule, 'ice_cube/rules/secondly_rule'
 
+  autoload :DayValidation, 'ice_cube/validations/day'
+  autoload :DayOfMonthValidation, 'ice_cube/validations/day_of_month'
+  autoload :DayOfWeekValidation, 'ice_cube/validations/day_of_week'
+  autoload :DayOfYearValidation, 'ice_cube/validations/day_of_year'
+  autoload :HourOfDayValidation, 'ice_cube/validations/hour_of_day'
+  autoload :MinuteOfHourValidation, 'ice_cube/validations/minute_of_hour'
+  autoload :MonthOfYearValidation, 'ice_cube/validations/month_of_year'
+  autoload :SecondOfMinuteValidation, 'ice_cube/validations/second_of_minute'
+
   VERSION = '0.2.3'
 
   IceCube::ONE_DAY = 24 * 60 * 60

data/lib/ice_cube/rule.rb

@@ -3,11 +3,9 @@ module IceCube
   class Rule
     
     attr_reader :occurrence_count, :until_date
-
-    SuggestionTypes = []
-    include MonthOfYearValidation, DayOfYearValidation, DayOfMonthValidation, DayOfWeekValidation, DayValidation
-    include HourOfDayValidation, MinuteOfHourValidation, SecondOfMinuteValidation
     
+    include ValidationTypes
+
     def to_hash
       hash = Hash.new
       hash[:rule_type] = self.class.name
@@ -22,7 +20,9 @@ module IceCube
       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]
+      hash[:validations].each do |validation, data|
+        data.is_a?(Array) ? rule.send(validation, *data) : rule.send(validation, data)
+      end
       rule
     end
     
@@ -76,8 +76,8 @@ module IceCube
     end
     
     def validate_single_date(date)
-      SuggestionTypes.all? do |s|
-        response = send("validate_#{s}", date)
+      @validation_types.values.all? do |validation|
+        response = validation.send(:validate, date)
         response.nil? || response
       end
     end
@@ -87,8 +87,9 @@ module IceCube
     # 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
+      suggestions = {}; 
+      @validation_types.each { |k, validation| suggestions[k] = validation.send(:closest, date) }
+      compact_suggestions = suggestions.values.compact
       # find the next date to go to
       if compact_suggestions.empty?
         next_date = date
@@ -99,23 +100,19 @@ module IceCube
         end
       else  
         loop do
-          compact_suggestions = suggestions.compact
+          compact_suggestions = suggestions.values.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]
+          @validation_types.each do |k, validation|
+            suggestions[k] = validation.send(:closest, min_suggestion) if min_suggestion == suggestions[k]
           end
         end
       end
     end
     
-    def to_s
-      to_ical
-    end
-    
-    attr_accessor :validations
+    attr_reader :validations
     
     private
     
@@ -124,32 +121,22 @@ module IceCube
       goal - goal.utc_offset + date.utc_offset
     end
     
+    # get a very meaningful string representation of this rule
+    def to_s_base(singular, plural)
+      representation = ''
+      representation = 'Every ' << ((@interval == 1) ? singular : "#{@interval} #{plural}")
+      representation << @validation_types.values.map { |v| ' ' + v.send(:to_s) }.join()
+      representation
+    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| IceCube::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 + IceCube::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]
+      @validation_types.values.each do |v|
+        representation << ';' << v.send(:to_ical)
+      end      
       representation << ";COUNT=#{@occurrence_count}" if @occurrence_count
       representation << ";UNTIL=#{@until_date}" if @until_date
       representation
@@ -160,6 +147,7 @@ module IceCube
     def initialize(interval = 1)
       throw ArgumentError.new('Interval must be > 0') unless interval > 0
       @validations = {}
+      @validation_types = {}
       @interval = interval
     end
     

data/lib/ice_cube/rules/daily_rule.rb

@@ -12,6 +12,10 @@ module IceCube
     def to_ical 
       'FREQ=DAILY' << to_ical_base
     end
+       
+    def to_s
+      to_s_base 'day', 'days'
+    end
         
     protected
     

data/lib/ice_cube/rules/hourly_rule.rb

@@ -13,6 +13,10 @@ module IceCube
       'FREQ=HOURLY' << to_ical_base
     end
         
+    def to_s
+      to_s_base 'hour', 'hours'
+    end
+        
     protected
     
     def default_jump(date)

data/lib/ice_cube/rules/minutely_rule.rb

@@ -13,6 +13,10 @@ module IceCube
       'FREQ=MINUTELY' << to_ical_base
     end
         
+    def to_s
+      to_s_base 'minute', 'minutes'
+    end
+        
     protected
     
     def default_jump(date)

data/lib/ice_cube/rules/monthly_rule.rb

@@ -17,6 +17,10 @@ module IceCube
       'FREQ=MONTHLY' << to_ical_base
     end
     
+    def to_s
+      to_s_base 'month', 'months'
+    end
+    
     protected
     
     def default_jump(date)

data/lib/ice_cube/rules/secondly_rule.rb

@@ -13,6 +13,10 @@ module IceCube
       'FREQ=SECONDLY' << to_ical_base
     end
         
+    def to_s
+      to_s_base 'second', 'seconds'
+    end
+        
     protected
            
     def default_jump(date)

data/lib/ice_cube/rules/weekly_rule.rb

@@ -15,6 +15,10 @@ module IceCube
       'FREQ=WEEKLY' << to_ical_base
     end
     
+    def to_s
+      to_s_base 'week', 'weeks'
+    end
+    
     protected
     
     def default_jump(date)

data/lib/ice_cube/rules/yearly_rule.rb

@@ -17,6 +17,10 @@ module IceCube
       'FREQ=YEARLY' << to_ical_base
     end
     
+    def to_s
+      to_s_base 'year', 'years'
+    end
+    
     protected
     
     # one year from now, the same month and day of the year

data/lib/ice_cube/validation.rb

@@ -0,0 +1,30 @@
+module IceCube
+  
+  class Validation
+     
+    NUMBER_SUFFIX = ['th', 'st', 'nd', 'rd', 'th', 'th', 'th', 'th', 'th', 'th']
+     
+    def adjust(goal, date)
+      return goal if goal.utc_offset == date.utc_offset
+      goal - goal.utc_offset + date.utc_offset
+    end
+    
+    def nice_numbers(array)
+      array.map { |d| nice_number(d) }.join(', ')
+    end
+    
+    private
+    
+    def nice_number(number)
+      if number == -1
+        'last'
+      elsif number < -1
+        number.abs.to_s << NUMBER_SUFFIX[number.abs % 10] << ' to last'
+      else
+        number.to_s << NUMBER_SUFFIX[number % 10]  
+      end
+    end
+    
+  end
+  
+end

data/lib/ice_cube/validation_types.rb

@@ -0,0 +1,138 @@
+module ValidationTypes
+  
+  def second_of_minute(*seconds)
+    @validations[:second_of_minute] ||= []
+    @validation_types[:second_of_minute] ||= SecondOfMinuteValidation.new(self)
+    seconds.each do |second|
+      raise ArgumentError.new('Argument must be a valid second') unless second < 60 && second >= 0
+      @validations[:second_of_minute] << second
+    end
+    # enforce uniqueness
+    @validations[:second_of_minute].uniq!
+    self
+  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] ||= []
+    @validation_types[:day] ||= DayValidation.new(self)
+    days.each do |day|
+      if day.is_a?(Integer)
+        # integer type argument
+        raise ArgumentError.new('Argument must be a valid day of week (0-6)') unless day >= 0 && day <= 6
+        @validations[:day] << day
+      else
+        # symbol type argument
+        raise ArgumentError.new('Argument must be a valid day of the week') unless IceCube::DAYS.has_key?(day)
+        @validations[:day] << IceCube::DAYS[day]
+      end
+    end
+    # enforce uniqueness
+    @validations[:day].uniq!
+    self
+  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] ||= []
+    @validation_types[:day_of_year] ||= DayOfYearValidation.new(self)
+    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
+    # enforce uniqueness
+    @validations[:day_of_year].uniq!
+    self
+  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] ||= []
+    @validation_types[:month_of_year] ||= MonthOfYearValidation.new(self)
+    months.each do |month|
+      if month.is_a?(Integer)
+        # integer type argument
+        raise ArgumentError.new('Argument must be a valid month (1-12)') unless month >= 1 && month <= 12
+        @validations[:month_of_year] << month
+      else
+        #symbol type argument
+        raise ArgumentError.new('Argument must be a valid month') unless IceCube::MONTHS.has_key?(month)
+        @validations[:month_of_year] << IceCube::MONTHS[month]
+      end
+    end
+    # enforce uniqueness
+    @validations[:month_of_year].uniq!
+    self
+  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)
+    puts days[0].to_s
+    @validations[:day_of_week] ||= {}
+    @validation_types[:day_of_week] ||= DayOfWeekValidation.new(self)
+    days.each do |day, occurrences|
+      unless day.is_a?(Integer)
+        raise ArgumentError.new('Argument must be a valid day of week') unless IceCube::DAYS.has_key?(day)
+        day = IceCube::DAYS[day]
+      end
+      raise ArgumentError.new('Argument must be a valid day of week (0-6)') unless day >= 0 && day <= 6
+      # add the day
+      @validations[:day_of_week][day] ||= []
+      @validations[:day_of_week][day].concat(occurrences)
+      @validations[:day_of_week][day].uniq!
+    end
+    self
+  end
+  
+  def hour_of_day(*hours)
+    @validations[:hour_of_day] ||= []
+    @validation_types[:hour_of_day] ||= HourOfDayValidation.new(self)
+    hours.each do |hour| 
+      raise ArgumentError.new('Argument must be a valid hour') unless hour < 24 && hour >= 0
+      @validations[:hour_of_day] << hour
+    end
+    # enforce uniqueness
+    @validations[:hour_of_day].uniq!
+    self
+  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] ||= []
+    @validation_types[:day_of_month] ||= DayOfMonthValidation.new(self)
+    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
+    # enforce uniqueness
+    @validations[:day_of_month].uniq!
+    self
+  end
+
+  def minute_of_hour(*minutes)
+    @validations[:minute_of_hour] ||= []
+    @validation_types[:minute_of_hour] ||= MinuteOfHourValidation.new(self)
+    minutes.each do |minute|
+      raise ArgumentError.new('Argument must be a valid minute') unless minute < 60 && minute >= 0
+      @validations[:minute_of_hour] << minute
+    end
+    # enforce uniqueness
+    @validations[:minute_of_hour].uniq!
+    self
+  end
+
+end

data/lib/ice_cube/validations/day.rb

@@ -1,36 +1,39 @@
-module DayValidation
+module IceCube
+
+  class DayValidation < Validation
   
-  def self.included(base)
-    base::SuggestionTypes << :day
-  end
+    def initialize(rule)
+      @days = rule.validations[:day]
+      @rule = rule
+    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 IceCube::DAYS.has_key?(day)
-      @validations[:day] << IceCube::DAYS[day]
+    def validate(date)
+      return true if !@days || @days.empty?
+      @days.include?(date.wday)
     end
-    self
-  end
   
-  def validate_day(date)
-    return true if !@validations[:day] || @validations[:day].empty?
-    @validations[:day].include?(date.wday)
-  end
+    def closest(date)
+      return nil if !@days || @days.empty?
+      # turn days into distances
+      days = @days.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 * IceCube::ONE_DAY
+      adjust(goal, date)
+    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)
+    def to_s
+      days_dup = (@days - @rule.validations[:day_of_week].keys if @rule.validations[:day_of_week]) || @days # don't list twice
+      'on every ' << days_dup.map { |d| Date::DAYNAMES[d] }.join(', ') unless days_dup.empty?
+    end
+
+    def to_ical
+      days_dup = (@days - @rule.validations[:day_of_week].keys if @rule.validations[:day_of_week]) || @days # don't list twice
+      'BYDAY=' << days_dup.map { |d| IceCube::ICAL_DAYS[d] }.join(',') unless days_dup.empty?
     end
-    days.compact!
-    # go to the closest distance away, the start of that day
-    goal = date + days.min * IceCube::ONE_DAY
-    adjust(goal, date)
-  end
   
+  end
+
 end

data/lib/ice_cube/validations/day_of_month.rb

@@ -1,51 +1,50 @@
-module DayOfMonthValidation
+module IceCube
+
+  class DayOfMonthValidation < Validation
     
-  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
+    def initialize(rule)
+      @days_of_month = rule.validations[:day_of_month]
     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 validate(date)
+      return true if !@days_of_month || @days_of_month.empty?
+      @days_of_month.include?(date.mday) || @days_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
+    def closest(date)
+      return nil if !@days_of_month || @days_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 = []
+      @days_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 * IceCube::ONE_DAY
+      adjust(goal, date)
     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 * IceCube::ONE_DAY
-    adjust(goal, date)
-  end
     
+    def to_s
+      'on the ' << nice_numbers(@days_of_month.sort) << (@days_of_month.count == 1 ? ' day' : ' days') << ' of the month' unless @days_of_month.empty?
+    end
+  
+    def to_ical
+      'BYMONTHDAY=' << @days_of_month.join(',') unless @days_of_month.empty?
+    end
+    
+  end
+  
 end

data/lib/ice_cube/validations/day_of_week.rb

@@ -1,41 +1,48 @@
-module DayOfWeekValidation
-  
-  def self.included(base)
-    base::SuggestionTypes << :day_of_week
-  end
+module IceCube
+
+  class DayOfWeekValidation < Validation
+
+    def initialize(rule)
+      @days_of_week = rule.validations[:day_of_week]
+      @rule = rule
+    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 IceCube::DAYS.has_key?(day)
-      @validations[:day_of_week][IceCube::DAYS[day]] ||= []
-      @validations[:day_of_week][IceCube::DAYS[day]].concat(occurrences)
+    def validate(date)
+      # is it even one of the valid days?
+      return true if !@days_of_week || @days_of_week.empty?
+      return false unless @days_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+
+      @days_of_week[date.wday].include?(nth_occurrence_of_weekday) || @days_of_week[date.wday].include?(nth_occurrence_of_weekday - this_weekday_in_month_count - 1)
     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(date)
+      return nil if !@days_of_week || @days_of_week.empty?
+      while date += IceCube::ONE_DAY
+        return date if validate(date)
+      end
+    end
+
+    def to_s
+      representation = ''
+      representation << 'on the '
+      representation << @days_of_week.map do |day, occ| 
+        nice_numbers(occ) << ' ' << Date::DAYNAMES[day] << (occ.count != 1 ? 's' : '') unless @days_of_week.empty?
+      end.join(' and the ')
+      representation
+    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 += IceCube::ONE_DAY
-      test = adjust(goal, date)
-      return test if validate_day_of_week(test)
+    def to_ical
+      representation = 'BYDAY='
+      @days_of_week.each do |day, occ|
+        representation << occ.map { |o| o.to_s + IceCube::ICAL_DAYS[day] }.join(',')
+      end
+      representation
     end
+
   end
   
 end

data/lib/ice_cube/validations/day_of_year.rb

@@ -1,51 +1,49 @@
-module DayOfYearValidation
+module IceCube
   
-  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
+  class DayOfYearValidation < Validation
+    
+    def initialize(rule)
+      @days_of_year = rule.validations[:day_of_year]
     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 validate(date)
+      return true if !@days_of_year || @days_of_year.empty?
+      @days_of_year.include?(date.yday) || @days_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
+    def closest(date)
+      return nil if !@days_of_year || @days_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 = []
+      @days_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 * IceCube::ONE_DAY
+      adjust(goal, date)
     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 * IceCube::ONE_DAY
-    adjust(goal, date)
-  end
   
+    def to_s
+      'on the ' << nice_numbers(@days_of_year.sort) << (@days_of_year.count == 1 ? ' day' : ' days') << ' of the year' unless @days_of_year.empty?
+    end
+  
+    def to_ical
+      'BYYEARDAY=' << @days_of_year.join(',') unless @days_of_year.empty?
+    end
+  
+  end
+
 end

data/lib/ice_cube/validations/hour_of_day.rb

@@ -1,35 +1,38 @@
-module HourOfDayValidation
+module IceCube
+
+  class HourOfDayValidation < Validation
   
-  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
+    def initialize(rule)
+      @hours_of_day = rule.validations[:hour_of_day]
     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 validate(date)
+      return true if !@hours_of_day || @hours_of_day.empty?
+      @hours_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
+    def closest(date)
+      return nil if !@hours_of_day || @hours_of_day.empty?
+      # turn hours into hour of day
+      # hour >= 24 should fall into the next day
+      hours = @hours_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 + IceCube::ONE_HOUR * closest_hour
+      adjust(goal, date)
+    end
+
+    def to_s
+      'on the ' << nice_numbers(@hours_of_day.sort) << (@hours_of_day.count == 1 ? ' hour' : ' hours') << ' of the day' unless @hours_of_day.empty?
     end
-    hours.compact!
-    # go to the closest distance away, the start of that hour
-    closest_hour = hours.min
-    goal = date + IceCube::ONE_HOUR * closest_hour
-    adjust(goal, date)
+
+    def to_ical
+      'BYHOUR=' << @hours_of_day.join(',') unless @hours_of_day.empty?
+    end
+  
   end
   
 end

data/lib/ice_cube/validations/minute_of_hour.rb

@@ -1,35 +1,38 @@
-module MinuteOfHourValidation
+module IceCube
+
+  class MinuteOfHourValidation < Validation
   
-  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
+    def initialize(rule)
+      @minutes_of_hour = rule.validations[:minute_of_hour]
     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 validate(date)
+      return true if !@minutes_of_hour || @minutes_of_hour.empty?
+      @minutes_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
+    def closest(date)
+      return nil if !@minutes_of_hour || @minutes_of_hour.empty?
+      # turn minutes into minutes of hour
+      # minute >= 60 should fall into the next hour
+      minutes = @minutes_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 * IceCube::ONE_MINUTE
+      adjust(goal, date)
+    end
+    
+    def to_s
+      'on the ' << nice_numbers(@minutes_of_hour.sort) << (@minutes_of_hour.count == 1 ? ' minute' : ' minutes') << ' of the hour' unless @minutes_of_hour.empty?
+    end
+
+    def to_ical
+      'BYMINUTE=' << @minutes_of_hour.join(',') unless @minutes_of_hour.empty?
     end
-    minutes.compact!
-    # go to the closest distance away, the beginning of that minute
-    closest_minute = minutes.min
-    goal = date + closest_minute * IceCube::ONE_MINUTE
-    adjust(goal, date)
+    
   end
   
 end

data/lib/ice_cube/validations/month_of_year.rb

@@ -1,39 +1,38 @@
-module MonthOfYearValidation
+module IceCube
+
+  class MonthOfYearValidation < Validation
   
-  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 IceCube::MONTHS.has_key?(month)
-      @validations[:month_of_year] << IceCube::MONTHS[month]
+    def initialize(rule)
+      @months_of_year = rule.validations[:month_of_year]
     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 validate(date)
+      return true if !@months_of_year || @months_of_year.empty?
+      @months_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
+    def closest(date)
+      return nil if !@months_of_year || @months_of_year.empty?
+      # turn months into month of year
+      # month > 12 should fall into the next year
+      months = @months_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) * IceCube::ONE_DAY }
+      adjust(goal, date)
+    end
+
+    def to_s
+      'in ' << @months_of_year.map { |m| Date::MONTHNAMES[m] }.join(', ') unless @months_of_year.empty?
+    end
+
+    def to_ical
+      'BYMONTH=' << @months_of_year.join(',') unless @months_of_year.empty?
     end
-    months.compact!
-    # go to the closest distance away
-    goal = date
-    months.min.times { goal += TimeUtil.days_in_month(goal) * IceCube::ONE_DAY }
-    adjust(goal, date)
+    
   end
   
 end

data/lib/ice_cube/validations/second_of_minute.rb

@@ -1,35 +1,38 @@
-module SecondOfMinuteValidation
+module IceCube
+
+  class SecondOfMinuteValidation < Validation
   
-  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
+    def initialize(rule)
+      @seconds_of_minute = rule.validations[:second_of_minute]
     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 validate(date)
+      return true if !@seconds_of_minute || @seconds_of_minute.empty?
+      @seconds_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
+    def closest(date)
+      return nil if !@seconds_of_minute || @seconds_of_minute.empty?
+      # turn seconds into seconds of minute
+      # second >= 60 should fall into the next minute
+      seconds = @seconds_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
+
+    def to_s
+      'on the ' << nice_numbers(@seconds_of_minute.sort) << (@seconds_of_minute.count == 1 ? ' second' : ' seconds') << ' of the minute' unless @seconds_of_minute.empty?
     end
-    seconds.compact!
-    # go to the closest distance away
-    closest_second = seconds.min
-    goal = date + closest_second
-    adjust(goal, date)
+
+    def to_ical
+      'BYSECOND=' << @seconds_of_minute.join(',') unless @seconds_of_minute.empty?
+    end
+  
   end
   
 end

data/lib/ice_cube/version.rb

@@ -1,5 +1,5 @@
 module IceCube
   
-  VERSION = "0.2.7"
+  VERSION = "0.2.8"
 
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 2
-  - 7
-  version: 0.2.7
+  - 8
+  version: 0.2.8
 platform: ruby
 authors: 
 - John Crepezzi
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-07 00:00:00 -04:00
+date: 2010-04-08 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -49,6 +49,8 @@ files:
 - lib/ice_cube/rules/yearly_rule.rb
 - lib/ice_cube/schedule.rb
 - lib/ice_cube/time_util.rb
+- lib/ice_cube/validation.rb
+- lib/ice_cube/validation_types.rb
 - lib/ice_cube/validations/day.rb
 - lib/ice_cube/validations/day_of_month.rb
 - lib/ice_cube/validations/day_of_week.rb