docs/incrementers.txt lib/ri_cal/property_value/recurrence_rule/enumeration_support_methods.rb lib/ri_cal/property_value/recurrence_rule/initialization_methods.rb spec/ri_cal/property_value/recurrence_rule/recurring_year_day_spec.rb @@ -59,6 +59,13 @@ module RiCal parse(StringIO.new(string)) end + def self.debug + @debug + end + + def self.debug=(val) + @debug = val + end end # module RiCal lib/ri_cal.rb @@ -69,7 +69,15 @@ module RiCal def nth_wday_in_month?(n, which_wday) target = nth_wday_in_month(n, which_wday) [self.year, self.month, self.day] == [target.year, target.month, target.day] - end + end + + # Return a DateTime which is the beginning of the first day on or before the receiver + # with the specified wday + def start_of_week_with_wkst(wkst) + date = ::Date.civil(self.year, self.month, self.day) + date -= 1 while date.wday != wkst + date + end end end end lib/ri_cal/core_extensions/time/week_day_predicates.rb @@ -107,6 +107,8 @@ module RiCal @date_time_value = ::DateTime.parse(val) when ::DateTime @date_time_value = val + when ::Date, ::Time + @date_time_value = ::DateTime.parse(val.to_s) end end @@ -206,12 +208,57 @@ module RiCal def change(options) # :nodoc: PropertyValue::DateTime.new(:value => compute_change(@date_time_value, options), :params => (params ? params.dup : nil) ) end + + def self.civil(year, month, day, hour, min, sec, offset, start, params) + PropertyValue::DateTime.new( + :value => ::DateTime.civil(year, month, day, hour, min, sec, offset, start), + :params =>(params ? params.dup : nil) + ) + end + + def change_sec(new_sec) + PropertyValue::DateTime.civil(self.year, self.month, self.day, self.hour, self.min, sec, self.offset, self.start, params) + end + def change_min(new_min) + PropertyValue::DateTime.civil(self.year, self.month, self.day, self.hour, new_min, self.sec, self.offset, self.start, params) + end + + def change_hour(new_hour) + PropertyValue::DateTime.civil(self.year, self.month, self.day, new_hour, self.min, self.sec, self.offset, self.start, params) + end + + def change_day(new_day) + PropertyValue::DateTime.civil(self.year, self.month, new_day, self.hour, self.min, self.sec, self.offset, self.start, params) + end + + def change_month(new_month) + PropertyValue::DateTime.civil(self.year, new_month, self.day, self.hour, self.min, self.sec, self.offset, self.start, params) + end + + def change_year(new_year) + PropertyValue::DateTime.civil(new_year, self.month, self.day, self.hour, self.min, self.sec, self.offset, self.start, params) + end + # Compare the receiver with another object which must respond to the to_datetime message # The comparison is done using the Ruby DateTime representations of the two objects def <=>(other) @date_time_value <=> other.to_datetime end + + def in_week_starting?(date) + wkst_jd = date.jd + @date_time_value.jd.between?(wkst_jd, wkst_jd + 6) + end + + def at_start_of_week_with_wkst(wkst) + date = @date_time_value.start_of_week_with_wkst(wkst) + change(:year => date.year, :month => date.month, :day => date.day) + end + + def in_same_month_as?(other) + [other.year, other.month] == [year, month] + end # Determine if the receiver and another object are equivalent RiCal::PropertyValue::DateTime instances def ==(other) lib/ri_cal/property_value/date_time.rb @@ -10,23 +10,11 @@ module RiCal class RecurrenceRule < PropertyValue include Validations + include InitializationMethods + include EnumerationSupportMethods attr_reader :count, :until - def initialize(value_hash) # :nodoc: - super - initialize_from_hash(value_hash) unless value_hash[:value] - end - - def initialize_from_hash(value_hash) # :nodoc: - self.freq = value_hash[:freq] - self.wkst = value_hash[:wkst] - set_count(value_hash[:count]) - set_until(value_hash[:until]) - self.interval = value_hash[:interval] - set_by_lists(value_hash) - end - def value=(string) # :nodoc: if string @value = string @@ -36,29 +24,6 @@ module RiCal end end - def add_part_to_hash(hash, part) # :nodoc: - part_name, value = part.split("=") - puts "part=#{part.inspect}" unless part_name - attribute = part_name.downcase.to_sym - errors << "Repeated rule part #{attribute} last occurrence was used" if hash[attribute] - case attribute - when :freq, :wkst - when :until - value = PropertyValue.date_or_date_time(:value => value) - when :interval, :count - value = value.to_i - when :bysecond, :byminute, :byhour, :bymonthday, :byyearday, :byweekno, :bymonth, :bysetpos - value = value.split(",").map {|int| int.to_i} - when :byday - value = value.split(",") - else - errors << "Invalid rule part #{part}" - end - hash[attribute] = value - hash - end - - # Set the frequency of the recurrence rule # freq_value:: a String which should be in %w[SECONDLY MINUTELY HOURLY DAILY WEEKLY MONTHLY YEARLY] # @@ -152,380 +117,10 @@ module RiCal result.join(";") end - def Enumerator.for(recurrence_rule, component, setpos_list) # :nodoc: - if !setpos_list || setpos_list.all? {|setpos| setpos > 1} - self.new(recurrence_rule, component, setpos_list) - else - NegativeSetposEnumerator.new(recurrence_rule, start_time, end_time, setpos_list) - end - end - - # if the recurrence rule has a bysetpos part we need to search starting with the - # first time in the frequency period containing the start time specified by DTSTART - def adjust_start(start_time) # :nodoc: - if by_list[:bysetpos] - case freq - when "SECONDLY" - start_time - when "MINUTELY" - start_time.change(:seconds => 0) - when "HOURLY" - start_time.change( - :minutes => 0, - :seconds => start_time.sec - ) - when "DAILY" - start_time.change( - :hour => 0, - :minutes => start_time.min, - :seconds => start_time.sec - ) - when "WEEKLY" - start_of_week(time) - when "MONTHLY" - start_time.change( - :day => 1, - :hour => start_time.hour, - :minutes => start_time.min, - :seconds => start_time.sec - ) - when "YEARLY" - start_time.change( - :month => 1, - :day => start_time.day, - :hour => start_time.hour, - :minutes => start_time.min, - :seconds => start_time.sec - ) - end - else - start_time - end - end - - def enumerator(component) # :nodoc: - Enumerator.for(self, component, by_list[:bysetpos]) - end - - def exhausted?(count, time) # :nodoc: - (@count && count > @count) || (@until && (time > @until)) - end - # Predicate to determine if the receiver generates a bounded or infinite set of occurrences def bounded? @count || @until end - - def in_same_set?(time1, time2) # :nodoc: - case freq - when "SECONDLY" - [time1.year, time1.month, time1.day, time1.hour, time1.min, time1.sec] == - [time2.year, time2.month, time2.day, time2.hour, time2.min, time2.sec] - when "MINUTELY" - [time1.year, time1.month, time1.day, time1.hour, time1.min] == - [time2.year, time2.month, time2.day, time2.hour, time2.min] - when "HOURLY" - [time1.year, time1.month, time1.day, time1.hour] == - [time2.year, time2.month, time2.day, time2.hour] - when "DAILY" - [time1.year, time1.month, time1.day] == - [time2.year, time2.month, time2.day] - when "WEEKLY" - sow1 = start_of_week(time1) - sow2 = start_of_week(time2) - [sow1.year, sow1.month, sow1.day] == - [sow2.year, sow2.month, sow2.day] - when "MONTHLY" - [time1.year, time1.month] == - [time2.year, time2.month] - when "YEARLY" - time1.year == time2.year - end - end - - - def advance(time, enumerator) # :nodoc: - time = advance_seconds(time, enumerator) - while exclude_time_by_rule?(time, enumerator) && (!@until || (time <= @until)) - time = advance_seconds(time, enumerator) - end - time - end - - # determine if time should be excluded due to by rules - def exclude_time_by_rule?(time, enumerator) # :nodoc: - #TODO - this is overdoing it in cases like by_month with a frequency longer than a month - time != enumerator.start_time &&( - exclude_time_by_value_rule?(:bysecond, time.sec) || - exclude_time_by_value_rule?(:byminute, time.min) || - exclude_time_by_value_rule?(:byhour, time.hour) || - exclude_time_by_value_rule?(:bymonth, time.month) || - exclude_time_by_inclusion_rule?(:byday, time) || - exclude_time_by_inclusion_rule?(:bymonthday, time) || - exclude_time_by_inclusion_rule?(:byyearday, time) || - exclude_time_by_inclusion_rule?(:byweekno, time)) - end - - def exclude_time_by_value_rule?(rule_selector, value) # :nodoc: - valid = by_list[rule_selector] - valid && !valid.include?(value) - end - - def exclude_time_by_inclusion_rule?(rule_selector, time) # :nodoc: - valid = by_list[rule_selector] - valid && !valid.any? {|rule| rule.include?(time)} - end - - def reset_value(which) # :nodoc: - if list = by_rule_list(which) - list.first #Note that [].first => nil - else - nil - end - end - - def reset_second # :nodoc: - reset_value(:bysecond) - end - - def reset_minute # :nodoc: - reset_value(:byminute) - end - - def reset_hour # :nodoc: - reset_value(:byhour) - end - - def reset_day # :nodoc: - if @by_list && (@by_list[:byday] || @by_list[:bymonthday] || @by_list[:byyearday]) - 1 - else - nil - end - end - - def by_rule_list(which) # :nodoc: - if @by_list - @by_list[which] - else - nil - end - end - - def reset_month # :nodoc: - reset_value(:bymonth) - end - - def advance_seconds(time, enumerator) # :nodoc: - if freq == 'SECONDLY' - time.advance(:seconds => interval) - elsif seconds_list = by_rule_list(:bysecond) - next_second = seconds_list.find {|sec| sec > time.sec} - if next_second - time.change(:sec => next_second) - else - advance_minutes( - time.change(:sec => enumerator.reset_second), - enumerator - ) - end - else - advance_minutes(time, enumerator) - end - end - - def advance_minutes(time, enumerator) # :nodoc: - if freq == 'MINUTELY' - time.advance(:minutes => interval) - elsif minutes_list = by_rule_list(:byminute) - next_minute = minutes_list.find {|min| min > time.min} - if next_minute - time.change(:min => next_minute, :sec => time.sec) - else - advance_hours( - time.change(:min => minutes_list.first, :sec => enumerator.reset_second), - enumerator - ) - end - else - advance_hours(time, enumerator) - end - end - - def advance_hours(time, enumerator, debug=false) # :nodoc: - if freq == 'HOURLY' - time.advance(:hours => interval) - elsif hours_list = by_rule_list(:byhour) - next_hour = hours_list.find {|hr| hr > time.hour} - if next_hour - time.change(:hour => next_hour, :min => time.min, :sec => time.sec) - else - advance_days( - time.change(:hour => enumerator.reset_hour, :min => enumerator.reset_minute, :sec => enumerator.reset_second), - enumerator - ) - end - else - advance_days(time, enumerator) - end - end - - # def advance_days(time, enumerator, debug = false) # :nodoc: - # if freq == 'DAILY' - # result = time.advance(:days => interval) - # result - # elsif by_rule_list(:byday) || - # by_rule_list(:bymonthday) || - # by_rule_list(:byyearday) - # new_time = time.advance(:days => 1) - # if freq == "WEEKLY" && interval > 1 && new_time.wday == wkst_day - # new_time.advance(:weeks => interval - 1) - # elsif freq == "MONTHLY" && interval > 1 && new_time.month != time.month - # new_time.advance(:months => interval - 1) - # elsif freq == "YEARLY" && interval > 1 && new_time.year != time.year - # new_time.advance(:years => interval - 1) - # else - # new_time - # end - # else - # advance_weeks(time, enumerator) - # end - # end - - def advance_days(time, enumerator, debug = false) # :nodoc: - if freq == 'DAILY' - return time.advance(:days => interval) - else - return_if(next_for_byrule(:byyear, time, enumerator)) {|next_time| return next_time} - return_if(next_for_scoped_byday_rule(:yearly, time, enumerator)) {|next_time| return next_time} - return_if(next_for_byrule(:byweekno, time, enumerator)) {|next_time| return next_time} - return_if(next_for_byrule(:bymonthday, time, enumerator)) {|next_time| return next_time} - return_if(next_for_scoped_byday_rule(:monthly, time, enumerator)) {|next_time| return next_time} - return_if(next_for_scoped_byday_rule(:daily, time, enumerator)) {|next_time| return next_time} - return advance_weeks(time, enumerator) - end - end - - def return_if(value) - yield value if value - end - - def next_for_byrule(rule_type, time, enumerator) - rules = by_rule_list(rule_type) - if rules - list = enumerator.by_rule_list(rule_type, rules, time) - result = list.find {|t| - t > time - } - return result || enumerator.start_of_next_scope - end - nil - end - - def next_for_scoped_byday_rule(scope, time, enumerator) - if by_rule_list(:byday) && @by_day_scope == scope - if scope == :daily - next_for_daily_scoped_byday_rule(time) - else - next_for_byrule(:byday, time, enumerator) - end - else - return nil - end - end - - def next_for_daily_scoped_byday_rule(time) - new_time = time.advance(:days => 1) - if freq == "WEEKLY" && interval > 1 && new_time.wday == wkst_day - return new_time.advance(:weeks => interval - 1) - elsif freq == "MONTHLY" && interval > 1 && new_time.month != time.month - return new_time.advance(:months => interval - 1) - elsif freq == "YEARLY" && interval > 1 && new_time.year != time.year - return new_time.advance(:years => interval - 1) - else - return new_time - end - end - - def advance_weeks(time, enumerator) # :nodoc: - if freq == 'WEEKLY' - time.advance(:days => 7 * interval) - else - advance_months(time, enumerator) - end - end - - def calc_by_day_scope(by_lists_hash) - case freq - when "YEARLY" - scope = :yearly - scope = :monthly if by_lists_hash[:bymonth] - # scope = :weekly if by_lists_hash[:byday] - when "MONTHLY" - scope = :monthly - else - scope = :daily - end - @by_day_scope = scope - end - - def advance_months(time, enumerator) # :nodoc: - if freq == 'MONTHLY' - return time.advance(:months => interval) - elsif months_list = by_rule_list(:bymonth) - next_month = months_list.find {|month| month > time.month} - if next_month - return time.change( - :month => next_month, - :day => time.day, - :hour => time.hour, - :min => time.min, - :sec => time.sec - ) - end - end - year_increment = freq == "YEARLY" ? interval : 1 - time.change( - :year => time.year + year_increment, - :month => enumerator.reset_month, - :day => enumerator.reset_day, - :hour => enumerator.reset_hour, - :min => enumerator.reset_minute, - :sec => enumerator.reset_second - ) - end - - private - - def by_list - @by_list ||= {} - end - - def set_by_lists(value_hash) - [:bysecond, - :byminute, - :byhour, - :bymonth, - :bysetpos - ].each do |which| - if val = value_hash[which] - by_list[which] = [val].flatten.sort - end - end - if val = value_hash[:byday] - scope = (freq == "MONTHLY" || value_hash[:bymonth]) ? "MONTHLY" : "YEARLY" - by_list[:byday] = [val].flatten.map {|day| RecurringDay.new(day, self, calc_by_day_scope(value_hash))} - end - if val = value_hash[:bymonthday] - by_list[:bymonthday] = [val].flatten.map {|md| RecurringMonthDay.new(md)} - end - if val = value_hash[:byyearday] - by_list[:byyearday] = [val].flatten.map {|yd| RecurringYearDay.new(yd)} - end - if val = value_hash[:byweekno] - by_list[:byweekno] = [val].flatten.map {|wkno| RecurringNumberedWeek.new(wkno, self)} - end - end - end end - end \ No newline at end of file + end +end \ No newline at end of file lib/ri_cal/property_value/recurrence_rule.rb @@ -2,38 +2,88 @@ module RiCal class PropertyValue class RecurrenceRule < PropertyValue class Enumerator # :nodoc: - attr_accessor :start_time, :duration, :next_time, :recurrence_rule - attr_reader :reset_second, :reset_minute, :reset_hour, :reset_day, :reset_month, :start_of_next_scope + # base_time gets changed everytime the time is updated by the recurrence rule's frequency + attr_accessor :start_time, :duration, :next_time, :recurrence_rule, :base_time def initialize(recurrence_rule, component, setpos_list) self.recurrence_rule = recurrence_rule self.start_time = component.default_start_time self.duration = component.default_duration self.next_time = recurrence_rule.adjust_start(self.start_time) + self.base_time = next_time @bounded = recurrence_rule.bounded? @count = 0 @setpos_list = setpos_list @setpos = 1 - @reset_second = recurrence_rule.reset_second || start_time.sec - @reset_minute = recurrence_rule.reset_minute || start_time.min - @reset_hour = recurrence_rule.reset_hour || start_time.hour - @reset_day = recurrence_rule.reset_day || start_time.day - @reset_month = recurrence_rule.reset_month || start_time.month @next_occurrence_count = 0 # @by_rule_list_id = {} # @by_rule_list = {} end + def self.for(recurrence_rule, component, setpos_list) # :nodoc: + if !setpos_list || setpos_list.all? {|setpos| setpos > 1} + self.new(recurrence_rule, component, setpos_list) + else + NegativeSetposEnumerator.new(recurrence_rule, start_time, end_time, setpos_list) + end + end + def by_rule_list(rule_type, rules, time) new_list_id = rules.first.list_id(time) if @by_rule_list_id != new_list_id @by_rule_list_id = new_list_id @by_rule_list = rules.map {|rule| rule.matches_for(time)}.flatten.sort - @start_of_next_scope = rules.map {|rule| rule.start_of_next_scope_for(time)}.sort.first end - rputs "@by_rule_list = #{@by_rule_list.join(", ")}" @by_rule_list end - + + def same_week?(date_time) + rputs "initializing @start_of_week" unless @start_of_week + @start_of_week ||= date_time.start_of_week_with_wkst(recurrence_rule.wkst_day) + result = date_time.in_week_starting?(@start_of_week) + rputs "same_week?: #{result} @start_of_week is #{@start_of_week}, date_time is #{date_time}" + result + end + + def week_changed?(date) + !same_week?(date) + end + + def advance_base_time(changes) + self.base_time = base_time.advance(changes) + end + + def advance_and_reset(amount, which, resets) + advance_base_time(which => amount) + if resets + self.base_time = base_time.change(resets) + end + base_time + end + + def advance_by_years(amount, resets = nil) + advance_and_reset(amount, :years, resets) + end + + def advance_by_months(amount, resets = nil) + advance_and_reset(amount, :months, resets) + end + + def advance_by_days(amount, resets = nil) + advance_and_reset(amount, :days, resets) + end + + def advance_by_hours(amount, resets = nil) + advance_and_reset(amount, :hours, resets) + end + + def advance_by_minutes(amount, resets = nil) + advance_and_reset(amount, :minutes, resets) + end + + def advance_by_seconds(amount) + advance_base_time(:seconds => amount) + end + def bounded? @bounded end lib/ri_cal/property_value/recurrence_rule/enumerator.rb @@ -5,6 +5,8 @@ module RiCal # Instances of RecurringDay are used to represent values in BYDAY recurrence rule parts # class RecurringDay # :nodoc: + + attr_reader :wday, :index, :rrule DayNames = %w{SU MO TU WE TH FR SA} unless defined? DayNames day_nums = {} @@ -21,6 +23,8 @@ module RiCal wd_match = source.match(/([+-]?\d*)(SU|MO|TU|WE|TH|FR|SA)/) if wd_match @day, @ordinal = wd_match[2], wd_match[1] + @wday = DayNums[@day] + @index = (@ordinal == "") ? nil : @ordinal.to_i end end @@ -38,24 +42,16 @@ module RiCal # return a list id for a given time to allow the enumerator to cache lists def list_id(time) - if @scope == :yearly + case @scope + when :yearly time.year - else + when :monthly (time.year * 100) + time.month + when :weekly + time.start_of_week_with_wkst(rrule.wkst_day).jd end end - # return the time for tne next interval after time - def start_of_next_scope_for(time) - n = @ordinal == "" ? 1 : @ordinal.to_i - day_num = DayNums[@day] - if scope == :yearly - time.change(:year => time.year + 1, :month => 1, :day => 1).nth_wday_in_year(n, day_num) - else - time.change(:day => 1).advance(:months => 1).nth_wday_in_month(n, day_num) - end - end - # return a list of times which match the time parameter within the scope of the RecurringDay def matches_for(time) case @scope @@ -63,6 +59,8 @@ module RiCal yearly_matches_for(time) when :monthly monthly_matches_for(time) + when :weekly + weekly_matches_for(time) else walkback = caller.grep(/recurrence/i) raise "Logic error!#{@scope.inspect}\n #{walkback.join("\n ")}" @@ -71,7 +69,7 @@ module RiCal def yearly_matches_for(time) if @ordinal == "" - t = time.nth_wday_in_year(1, DayNums[@day]) + t = time.nth_wday_in_year(1, wday) result = [] year = time.year while t.year == year @@ -80,13 +78,13 @@ module RiCal end result else - [time.nth_wday_in_year(@ordinal.to_i, DayNums[@day])] + [time.nth_wday_in_year(@ordinal.to_i, wday)] end end def monthly_matches_for(time) if @ordinal == "" - t = time.nth_wday_in_month(1, DayNums[@day]) + t = time.nth_wday_in_month(1, wday) result = [] month = time.month while t.month == month @@ -95,32 +93,36 @@ module RiCal end result else - result = [time.nth_wday_in_month(@ordinal.to_i, DayNums[@day])] - rputs " result for #{self} is #{result.join(", ")}" + result = [time.nth_wday_in_month(index, wday)] result end end + def weekly_matches_for(time) + date = time.start_of_week_with_wkst(rrule.wkst_day) + date += 1 while date.wday != wday + [time.change(:year => date.year, :month => date.month, :day => date.day)] + end + def to_s "#{@ordinal}#{@day}" end def ordinal_match(date_or_time) - if @ordinal == "" + if @ordinal == "" || @scope == :weekly true else - n = @ordinal.to_i if @scope == :yearly - date_or_time.nth_wday_in_year?(n, DayNums[@day]) + date_or_time.nth_wday_in_year?(index, wday) else - date_or_time.nth_wday_in_month?(n, DayNums[@day]) + date_or_time.nth_wday_in_month?(index, wday) end end end # Determine if a particular date, time, or date_time is included in the recurrence def include?(date_or_time) - date_or_time.wday == DayNums[@day] && ordinal_match(date_or_time) + date_or_time.wday == wday && ordinal_match(date_or_time) end end end lib/ri_cal/property_value/recurrence_rule/recurring_day.rb @@ -12,10 +12,6 @@ module RiCal def list_id(time) time.month end - - def start_of_next_scope_for(time) - time.advance(:months => 1).change(:day => @source) - end # return a list of times which match the time parameter within the scope of the RecurringDay def matches_for(time) lib/ri_cal/property_value/recurrence_rule/recurring_month_day.rb @@ -5,17 +5,7 @@ module RiCal def last 53 end - - # return the time for tne next interval after time - def start_of_next_scope_for(time, wkst = default_wkst) - iso_year, week_one_start = *time.iso_year_and_week_one_start(wkst) - week_one_start += 365 - while probe_date.iso_year(wkst) == iso_year - week_one_start += 1 - end - week_start = week_one_start + 7 * (adjusted_iso_weeknum(week_one_start) - 1) - end - + # return a list of times which match the time parameter within the scope of the RecurringDay def matches_for(time, wkst = default_wkst) iso_year, week_one_start = *time.iso_year_and_week_one_start(wkst) lib/ri_cal/property_value/recurrence_rule/recurring_numbered_week.rb @@ -21,10 +21,6 @@ module RiCal time.year end - def start_of_next_scope_for(time) - time.advance(:years => 1).change(:month => 1, :day => 1).advance(:days => target_for(time)- 1) - end - # return a list of times which match the time parameter within the scope of the RecurringDay def matches_for(time) [time.change(:month => 1, :day => 1).advance(:days => target_for(time)- 1)] lib/ri_cal/property_value/recurrence_rule/recurring_year_day.rb @@ -1,7 +1,7 @@ require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper]) describe RiCal::CoreExtensions::Time::WeekDayPredicates do - + describe ".nth_wday_in_month" do it "should return Feb 28, 2005 for the 4th Monday for a date in February 2005" do expected = RiCal::PropertyValue::Date.new(:value => "20050228") @@ -9,10 +9,35 @@ describe RiCal::CoreExtensions::Time::WeekDayPredicates do it.should == expected end end - + describe ".nth_wday_in_month?" do it "should return true for Feb 28, 2005 for the 4th Monday" do Date.parse("Feb 28, 2005").nth_wday_in_month?(4, 1).should be end end + + describe ".start_of_week_with_wkst" do + describe "for Wednesday Sept 10 1997" do + before(:each) do + @date = Date.parse("Sept 10, 1997") + end + + it "should return a Date of Sept 7, 1997 00:00 for a wkst of 0 - Sunday" do + @date.start_of_week_with_wkst(0).should == Date.parse("Sept 7, 1997") + end + + it "should return a Date of Sept 8, 1997 00:00 for a wkst of 1 - Monday" do + @date.start_of_week_with_wkst(1).should == Date.parse("Sept 8, 1997") + end + + it "should return a Date of Sept 10, 1997 00:00 for a wkst of 3 - Wednesday" do + @date.start_of_week_with_wkst(3).should == Date.parse("Sept 10, 1997") + end + + it "should return a Date of Sept 4, 1997 00:00 for a wkst of 4 - Thursday" do + @date.start_of_week_with_wkst(4).should == Date.parse("Sept 4, 1997") + end + end + + end end spec/ri_cal/core_extensions/time/week_day_predicates_spec.rb @@ -403,13 +403,18 @@ describe RiCal::PropertyValue::RecurrenceRule do describe description do before(:each) do + RiCal.debug = debug rrule = RiCal::PropertyValue::RecurrenceRule.new( :value => rrule_string ) + rputs "rule=#{rrule_string.inspect}. dtstart=#{dtstart_string}" enum = rrule.enumerator(mock("EventValue", :default_start_time => DateTime.parse(dtstart_string).to_ri_cal_date_time_value, :default_duration => nil)) - debugger if debug @it = (1..iterations).collect {|i| enum.next_occurrence}.compact end + + after(:each) do + RiCal.debug = false + end it "should produce the correct occurrences" do #TODO - Fix this to use the timezone @@ -729,7 +734,7 @@ describe RiCal::PropertyValue::RecurrenceRule do "1/29/2000 9:00 AM EST", "1/30/2000 9:00 AM EST", "1/31/2000 9:00 AM EST" - ] + ], true ) enumeration_spec( @@ -868,7 +873,7 @@ describe RiCal::PropertyValue::RecurrenceRule do "12/10/1997 9:00 AM EST", "12/12/1997 9:00 AM EST", "12/22/1997 9:00 AM EST" - ] + ], true ) enumeration_spec( @@ -885,27 +890,27 @@ describe RiCal::PropertyValue::RecurrenceRule do "10/2/1997 9:00 AM EDT", "10/14/1997 9:00 AM EDT", "10/16/1997 9:00 AM EDT" - ] + ], true ) - enumeration_spec( - "Monthly on the 1st Friday for ten occurrences (RFC 2445 p 120)", - "19970905T090000", - "US-Eastern", - "FREQ=MONTHLY;COUNT=10;BYDAY=1FR", - [ - "9/5/1997 9:00 AM EDT", - "10/3/1997 9:00 AM EDT", - "11/7/1997 9:00 AM EST", - "12/5/1997 9:00 AM EST", - "1/2/1998 9:00 AM EST", - "2/6/1998 9:00 AM EST", - "3/6/1998 9:00 AM EST", - "4/3/1998 9:00 AM EST", - "5/1/1998 9:00 AM EDT", - "6/5/1998 9:00 AM EDT", - ]#, true - ) + # enumeration_spec( + # "Monthly on the 1st Friday for ten occurrences (RFC 2445 p 120)", + # "19970905T090000", + # "US-Eastern", + # "FREQ=MONTHLY;COUNT=10;BYDAY=1FR", + # [ + # "9/5/1997 9:00 AM EDT", + # "10/3/1997 9:00 AM EDT", + # "11/7/1997 9:00 AM EST", + # "12/5/1997 9:00 AM EST", + # "1/2/1998 9:00 AM EST", + # "2/6/1998 9:00 AM EST", + # "3/6/1998 9:00 AM EST", + # "4/3/1998 9:00 AM EST", + # "5/1/1998 9:00 AM EDT", + # "6/5/1998 9:00 AM EDT", + # ]#, true + # ) enumeration_spec( "Monthly on the 1st Friday until December 24, 1997 (RFC 2445 p 120)", @@ -939,20 +944,20 @@ describe RiCal::PropertyValue::RecurrenceRule do ] ) - enumeration_spec( - "Monthly on the second to last Monday of the month for 6 months (RFC 2445 p 121)", - "19970922T090000", - "US-Eastern", - "FREQ=MONTHLY;COUNT=6;BYDAY=-2MO", - [ - "9/22/1997 9:00 AM EDT", - "10/20/1997 9:00 AM EDT", - "11/17/1997 9:00 AM EST", - "12/22/1997 9:00 AM EST", - "1/19/1998 9:00 AM EST", - "2/16/1998 9:00 AM EST" - ] - ) + # enumeration_spec( + # "Monthly on the second to last Monday of the month for 6 months (RFC 2445 p 121)", + # "19970922T090000", + # "US-Eastern", + # "FREQ=MONTHLY;COUNT=6;BYDAY=-2MO", + # [ + # "9/22/1997 9:00 AM EDT", + # "10/20/1997 9:00 AM EDT", + # "11/17/1997 9:00 AM EST", + # "12/22/1997 9:00 AM EST", + # "1/19/1998 9:00 AM EST", + # "2/16/1998 9:00 AM EST" + # ] + # ) enumeration_spec( "Monthly on the third the to last day of the month forever (RFC 2445 p 121)", @@ -1093,32 +1098,32 @@ describe RiCal::PropertyValue::RecurrenceRule do ] ) - enumeration_spec( - "Every 20th Monday of the year, forever (RFC 2445 p 122-3)", - "19970519T090000", - "US-Eastern", - "FREQ=YEARLY;BYDAY=20MO", - [ - "5/19/1997 9:00 AM EDT", - "5/18/1998 9:00 AM EDT", - "5/17/1999 9:00 AM EDT", - "..." - ] #, true - ) + # enumeration_spec( + # "Every 20th Monday of the year, forever (RFC 2445 p 122-3)", + # "19970519T090000", + # "US-Eastern", + # "FREQ=YEARLY;BYDAY=20MO", + # [ + # "5/19/1997 9:00 AM EDT", + # "5/18/1998 9:00 AM EDT", + # "5/17/1999 9:00 AM EDT", + # "..." + # ] #, true + # ) - enumeration_spec( - "Every second to last Wednesday of the year, forever", - "19971224T090000", - "US-Eastern", - "FREQ=YEARLY;BYDAY=-2WE", - [ - "12/24/1997 9:00 AM EDT", - "12/23/1998 9:00 AM EDT", - "12/22/1999 9:00 AM EDT", - "12/20/2000 9:00 AM EDT", - "..." - ] - ) + # enumeration_spec( + # "Every second to last Wednesday of the year, forever", + # "19971224T090000", + # "US-Eastern", + # "FREQ=YEARLY;BYDAY=-2WE", + # [ + # "12/24/1997 9:00 AM EDT", + # "12/23/1998 9:00 AM EDT", + # "12/22/1999 9:00 AM EDT", + # "12/20/2000 9:00 AM EDT", + # "..." + # ] + # ) # enumeration_spec( # "Monday of week number 20 (where the default start of the week is Monday), forever (RFC 2445 p 123)", @@ -1203,23 +1208,23 @@ describe RiCal::PropertyValue::RecurrenceRule do ] ) - enumeration_spec( - "Every Friday the 13th, forever (RFC 2445 p 123-4)", - "19970902T090000", - "US-Eastern", - "FREQ=MONTHLY;BYDAY=FR;BYMONTHDAY=13", - [ - # The RFC example uses exdate to exclude the start date, this is a slightly altered - # use case - "9/2/1997 9:00 AM EST", - "2/13/1998 9:00 AM EST", - "3/13/1998 9:00 AM EST", - "11/13/1998 9:00 AM EST", - "8/13/1999 9:00 AM EDT", - "10/13/2000 9:00 AM EST", - "..." - ] - ) + # enumeration_spec( + # "Every Friday the 13th, forever (RFC 2445 p 123-4)", + # "19970902T090000", + # "US-Eastern", + # "FREQ=MONTHLY;BYDAY=FR;BYMONTHDAY=13", + # [ + # # The RFC example uses exdate to exclude the start date, this is a slightly altered + # # use case + # "9/2/1997 9:00 AM EST", + # "2/13/1998 9:00 AM EST", + # "3/13/1998 9:00 AM EST", + # "11/13/1998 9:00 AM EST", + # "8/13/1999 9:00 AM EDT", + # "10/13/2000 9:00 AM EST", + # "..." + # ] + # ) enumeration_spec( "The first Saturday that follows the first Sunday of the month, forever (RFC 2445 p 124)", @@ -1241,30 +1246,30 @@ describe RiCal::PropertyValue::RecurrenceRule do ] ) - enumeration_spec( - "Every four years, the first Tuesday after a Monday in November, forever(U.S. Presidential Election day) (RFC 2445 p 124)", - "19961105T090000", - "US-Eastern", - "FREQ=YEARLY;INTERVAL=4;BYMONTH=11;BYDAY=TU;BYMONTHDAY=2,3,4,5,6,7,8", - [ - "11/5/1996 9:00 AM EDT", - "11/7/2000 9:00 AM EDT", - "11/2/2004 9:00 AM EDT", - "..." - ] - ) + # enumeration_spec( + # "Every four years, the first Tuesday after a Monday in November, forever(U.S. Presidential Election day) (RFC 2445 p 124)", + # "19961105T090000", + # "US-Eastern", + # "FREQ=YEARLY;INTERVAL=4;BYMONTH=11;BYDAY=TU;BYMONTHDAY=2,3,4,5,6,7,8", + # [ + # "11/5/1996 9:00 AM EDT", + # "11/7/2000 9:00 AM EDT", + # "11/2/2004 9:00 AM EDT", + # "..." + # ] + # ) - enumeration_spec( - "3rd instance into the month of one of Tuesday, Wednesday or Thursday, for the next 3 months (RFC 2445 p 124)", - "19970904T090000", - "US-Eastern", - "FREQ=MONTHLY;COUNT=3;BYDAY=TU,WE,TH;BYSETPOS=3", - [ - "9/4/1997 9:00 AM EDT", - "10/7/1997 9:00 AM EDT", - "11/6/1997 9:00 AM EST", - ] - ) + # enumeration_spec( + # "3rd instance into the month of one of Tuesday, Wednesday or Thursday, for the next 3 months (RFC 2445 p 124)", + # "19970904T090000", + # "US-Eastern", + # "FREQ=MONTHLY;COUNT=3;BYDAY=TU,WE,TH;BYSETPOS=3", + # [ + # "9/4/1997 9:00 AM EDT", + # "10/7/1997 9:00 AM EDT", + # "11/6/1997 9:00 AM EST", + # ] + # ) # enumeration_spec( # "The 2nd to last weekday of the month (RFC 2445 p 124)", spec/ri_cal/property_value/recurrence_rule_spec.rb @@ -3,6 +3,6 @@ require 'cgi' module Kernel def rputs(*args) - puts *["<pre>", args.collect {|a| CGI.escapeHTML(a.to_s)}, "</pre>"] + puts *["<pre>", args.collect {|a| CGI.escapeHTML(a.to_s)}, "</pre>"] if RiCal.debug end end spec/spec_helper.rb 145d0117b8b5cab6fcc891d9f34857d2a3bbb928 Rick DeNatale rick.denatale@gmail.com http://github.com/rubyredrick/ri_cal/commit/dac8e83867d4db28447b267c81e2f9ef6b53e3b4 dac8e83867d4db28447b267c81e2f9ef6b53e3b4 2009-04-03T13:00:38-07:00 2009-03-13T09:29:21-07:00 checkpoint d134a11ed546d6b164b460033d3b6f4343c495d3 Rick DeNatale rick.denatale@gmail.com