demingfactor-ri_cal 0.9.0

data/lib/ri_cal/property_value/recurrence_rule/occurrence_incrementer/yearly_incrementer.rb

@@ -0,0 +1,57 @@
+module RiCal
+  class PropertyValue
+    class RecurrenceRule < PropertyValue
+      #- ©2009 Rick DeNatale, All rights reserved. Refer to the file README.txt for the license
+      #
+      class OccurrenceIncrementer # :nodoc:
+         class YearlyIncrementer < FrequencyIncrementer #:nodoc:
+
+           attr_reader :wkst
+
+           def initialize(rrule, sub_cycle_incrementer)
+             @wkst = rrule.wkst_day
+             super(rrule, sub_cycle_incrementer)
+           end
+
+           def self.from_rrule(rrule, start_time)
+             conditional_incrementer(rrule, "YEARLY", ByMonthIncrementer)
+           end
+
+           def advance_what
+             :years
+           end
+
+           def step(date_time)
+             if contains_weeknum_incrementer?
+               result = date_time
+               multiplier.times do
+                 result = result.at_start_of_next_iso_year(wkst)
+               end
+               result
+             else
+               super(date_time)
+             end
+           end
+
+           def start_of_cycle(date_time)
+             if contains_weeknum_incrementer?
+               date_time.at_start_of_iso_year(wkst)
+             elsif contains_daily_incrementer?
+               date_time.change(:month => 1, :day => 1)
+             else
+               date_time.change(:month => 1)
+             end
+           end
+
+           def end_of_occurrence(date_time)
+             if contains_weeknum_incrementer?
+               date_time.end_of_iso_year(wkst)
+             else
+               date_time.end_of_year
+             end
+           end
+        end
+      end
+    end
+  end
+end

data/lib/ri_cal/property_value/recurrence_rule/occurrence_incrementer.rb

@@ -0,0 +1,135 @@
+module RiCal
+  class PropertyValue
+    class RecurrenceRule < PropertyValue
+      #- ©2009 Rick DeNatale, All rights reserved. Refer to the file README.txt for the license
+      #
+      class OccurrenceIncrementer # :nodoc:
+
+        attr_accessor :sub_cycle_incrementer, :current_occurrence, :outer_range
+        attr_accessor :outer_incrementers
+        attr_accessor :contains_daily_incrementer, :contains_weeknum_incrementer
+        attr_reader :leaf_iterator
+        parent_path = "ri_cal/property_value/recurrence_rule/occurrence_incrementer"
+
+        autoload :ByDayIncrementer, "#{parent_path}/by_day_incrementer.rb"
+        autoload :ByHourIncrementer, "#{parent_path}/by_hour_incrementer.rb"
+        autoload :ByMinuteIncrementer, "#{parent_path}/by_minute_incrementer.rb"
+        autoload :ByMonthIncrementer, "#{parent_path}/by_month_incrementer.rb"
+        autoload :ByMonthdayIncrementer, "#{parent_path}/by_monthday_incrementer.rb"
+        autoload :ByNumberedDayIncrementer, "#{parent_path}/by_numbered_day_incrementer.rb"
+        autoload :BySecondIncrementer, "#{parent_path}/by_second_incrementer.rb"
+        autoload :ByYeardayIncrementer, "#{parent_path}/by_yearday_incrementer.rb"
+        autoload :ByWeekNoIncrementer, "#{parent_path}/by_weekno_incrementer.rb"
+        autoload :DailyIncrementer, "#{parent_path}/daily_incrementer.rb"
+        autoload :FrequencyIncrementer, "#{parent_path}/frequency_incrementer.rb"
+        autoload :HourlyIncrementer, "#{parent_path}/hourly_incrementer.rb"
+        autoload :ListIncrementer, "#{parent_path}/list_incrementer.rb"
+        autoload :MinutelyIncrementer, "#{parent_path}/minutely_incrementer.rb"
+        autoload :MonthlyIncrementer, "#{parent_path}/monthly_incrementer.rb"
+        autoload :NullSubCycleIncrementer, "#{parent_path}/null_sub_cycle_incrementer.rb"
+        autoload :SecondlyIncrementer, "#{parent_path}/secondly_incrementer.rb"
+        autoload :WeeklyIncrementer, "#{parent_path}/weekly_incrementer.rb"
+        autoload :YearlyIncrementer, "#{parent_path}/yearly_incrementer.rb"
+
+        include RecurrenceRule::TimeManipulation
+
+        def initialize(rrule, sub_cycle_incrementer)
+          self.sub_cycle_incrementer = sub_cycle_incrementer
+          @outermost = true
+          self.outer_incrementers = []
+          if sub_cycle_incrementer
+            self.contains_daily_incrementer = sub_cycle_incrementer.daily_incrementer? ||
+              sub_cycle_incrementer.contains_daily_incrementer?
+            self.contains_weeknum_incrementer = sub_cycle_incrementer.weeknum_incrementer?||
+              sub_cycle_incrementer.contains_weeknum_incrementer?
+            sub_cycle_incrementer.add_outer_incrementer(self)
+          else
+            self.sub_cycle_incrementer = NullSubCycleIncrementer
+          end
+        end
+
+        def self.from_rrule(recurrence_rule, start_time)
+          YearlyIncrementer.from_rrule(recurrence_rule, start_time)
+        end
+
+        def add_outer_incrementer(incrementer)
+          @outermost = false
+          self.outer_incrementers << incrementer
+          sub_cycle_incrementer.add_outer_incrementer(incrementer)
+        end
+
+        def outermost?
+          @outermost
+        end
+
+        def to_s
+          if sub_cycle_incrementer
+            "#{self.short_name}->#{sub_cycle_incrementer}"
+          else
+            self.short_name
+          end
+        end
+
+        def short_name
+          @short_name ||= self.class.name.split("::").last
+        end
+
+        # Return the next time after previous_occurrence generated by this incrementer
+        # But the occurrence is outside the current cycle of any outer incrementer(s) return
+        # nil which will cause the outer incrementer to step to its next cycle
+        def next_time(previous_occurrence)
+          @previous_occurrence = previous_occurrence
+          if current_occurrence
+            sub_occurrence = @sub_cycle_incrementer.next_time(previous_occurrence)
+          else #first time
+            sub_occurrence = @sub_cycle_incrementer.first_sub_occurrence(previous_occurrence, update_cycle_range(previous_occurrence))
+          end
+          if sub_occurrence
+            candidate = sub_occurrence
+          else
+            candidate = next_cycle(previous_occurrence)
+          end
+          if in_outer_cycle?(candidate)
+            candidate
+          else
+            nil
+          end
+        end
+
+        def update_cycle_range(date_time)
+          self.current_occurrence = date_time
+          (date_time..end_of_occurrence(date_time))
+        end
+
+        def in_outer_cycle?(candidate)
+          candidate && (outer_range.nil? || (outer_range.first <= candidate && outer_range.last >= candidate))
+        end
+
+        def first_sub_occurrence(previous_occurrence, outer_cycle_range)
+          first_within_outer_cycle(previous_occurrence, outer_cycle_range)
+        end
+
+        # Advance to the next cycle, if the result is within the current cycles of all outer incrementers
+        def next_cycle(previous_occurrence)
+          raise "next_cycle is a subclass responsibility"
+        end
+
+        def contains_daily_incrementer?
+          @contains_daily_incrementer
+        end
+
+        def daily_incrementer?
+          false
+        end
+
+        def contains_weeknum_incrementer?
+          @contains_weeknum_incrementer
+        end
+
+        def weeknum_incrementer?
+          false
+        end
+      end
+    end
+  end
+end

data/lib/ri_cal/property_value/recurrence_rule/recurring_day.rb

@@ -0,0 +1,131 @@
+module RiCal
+  class PropertyValue
+    class RecurrenceRule < PropertyValue
+      #- ©2009 Rick DeNatale, All rights reserved. Refer to the file README.txt for the license
+      #
+      # 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 = {}
+        unless defined? DayNums
+          DayNames.each_with_index { |name, i| day_nums[name] = i }
+          DayNums = day_nums
+        end
+
+        attr_reader :source, :scope
+        def initialize(source, rrule, scope = :monthly)
+          @source = source
+          @rrule = rrule
+          @scope = scope
+          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
+
+        def valid?
+          !@day.nil?
+        end
+
+        def ==(another)
+          self.class === another && to_a = another.to_a
+        end
+
+        def to_a
+          [@day, @ordinal]
+        end
+        
+        # return a list id for a given time to allow the enumerator to cache lists
+        def list_id(time)
+          case @scope
+          when :yearly
+            time.year
+          when :monthly
+            (time.year * 100) + time.month
+          when :weekly
+            time.at_start_of_week_with_wkst(rrule.wkst_day).jd
+          end
+        end
+        
+        # return a list of times which match the time parameter within the scope of the RecurringDay
+        def matches_for(time)
+          case @scope
+          when :yearly
+            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  ")}"
+          end         
+        end
+        
+        def yearly_matches_for(time)
+          if @ordinal == ""
+            t = time.nth_wday_in_year(1, wday)
+            result = []
+            year = time.year
+            while t.year == year
+              result << t
+              t = t.advance(:week => 1)
+            end
+            result
+          else
+            [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, wday)
+            result = []
+            month = time.month
+            while t.month == month
+              result << t
+              t = t.advance(:days => 7)
+            end
+            result
+          else
+            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 == "" || @scope == :weekly
+            true
+          else
+            if @scope == :yearly
+              date_or_time.nth_wday_in_year?(index, wday) 
+            else
+              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 == wday && ordinal_match(date_or_time)
+        end
+      end
+    end
+  end
+end

data/lib/ri_cal/property_value/recurrence_rule/recurring_month_day.rb

@@ -0,0 +1,64 @@
+module RiCal
+  class PropertyValue
+    class RecurrenceRule < PropertyValue
+      #- ©2009 Rick DeNatale, All rights reserved. Refer to the file README.txt for the license
+      #
+      # Instances of RecurringMonthDay represent BYMONTHDAY parts in recurrence rules
+      class RecurringMonthDay < NumberedSpan # :nodoc:
+
+        def last
+          31
+        end
+        
+        # return a list id for a given time to allow the enumerator to cache lists
+        def list_id(time)
+          time.month
+        end
+ 
+        # return a list of times which match the time parameter within the scope of the RecurringDay
+        def matches_for(time)
+          [time.change(:day => 1).advance(:days => target_for(time)- 1)]
+        end
+        
+        # return a list id for a given time to allow the enumerator to cache lists
+        def list_id(time)
+          time.month
+        end
+ 
+        # return a list of times which match the time parameter within the scope of the RecurringDay
+        def matches_for(time)
+          [time.change(:day => 1).advance(:days => target_for(time)- 1)]
+        end
+        
+        def target_date_time_for(date_time)
+          matches_for(date_time)[0]
+        end
+
+        # return a list of times which match the time parameter within the scope of the RecurringDay
+        def matches_for(time)
+          [time.change(:day => 1).advance(:days => target_for(time)- 1)]
+        end
+
+        def target_date_time_for(date_time)
+          matches_for(date_time)[0]
+        end
+        
+        def fixed_day?
+          @source > 0
+        end
+
+        def target_for(date_or_time)
+          if fixed_day?
+            @source
+          else
+            date_or_time.days_in_month + @source + 1
+          end
+        end
+
+        def include?(date_or_time)
+          date_or_time.mday == target_for(date_or_time)
+        end
+      end
+    end
+  end
+end

data/lib/ri_cal/property_value/recurrence_rule/recurring_numbered_week.rb

@@ -0,0 +1,33 @@
+module RiCal
+  class PropertyValue
+    class RecurrenceRule < PropertyValue
+      #- ©2009 Rick DeNatale, All rights reserved. Refer to the file README.txt for the license
+      #
+      class RecurringNumberedWeek < NumberedSpan # :nodoc:
+        def last
+          53
+        end
+         
+        def rule_wkst
+          @rule && rule.wkst_day
+        end
+        
+        def default_wkst
+          rule_wkst || 1
+        end
+        
+        def adjusted_iso_weeknum(date_or_time)
+          if @source > 0
+            @source
+          else
+            date_or_time.iso_weeks_in_year(wkst) + @source + 1
+          end
+        end
+        
+        def include?(date_or_time, wkst=default_wkst)
+          date_or_time.iso_week_num(wkst) == adjusted_iso_weeknum(date_or_time)
+        end
+      end
+    end
+  end
+end

data/lib/ri_cal/property_value/recurrence_rule/recurring_year_day.rb

@@ -0,0 +1,53 @@
+module RiCal
+  class PropertyValue
+    class RecurrenceRule < PropertyValue
+      #- ©2009 Rick DeNatale, All rights reserved. Refer to the file README.txt for the license
+      #
+      class RecurringYearDay < NumberedSpan # :nodoc:
+
+        def last
+          366
+        end
+
+        def leap_year?(year)
+          year % 4 == 0 && (year % 400 == 0 || year % 100 != 0)
+        end 
+
+
+        def length_of_year(year)
+          leap_year?(year) ? 366 : 365
+        end 
+        
+        # return a list id for a given time to allow the enumerator to cache lists
+        def list_id(time)
+          time.year
+        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)]
+        end
+        
+        def target_date_time_for(date_time)
+          matches_for(date_time)[0]
+        end
+        
+        def fixed_day?
+          @source > 0
+        end
+
+        def target_for(date_or_time)
+          if fixed_day?
+            @source
+          else
+            length_of_year(date_or_time.year) + @source + 1
+          end
+        end
+        
+        def include?(date_or_time)
+          date_or_time.yday == target_for(date_or_time)
+        end
+      end
+    end
+  end
+end

data/lib/ri_cal/property_value/recurrence_rule/time_manipulation.rb

@@ -0,0 +1,42 @@
+module RiCal
+  class PropertyValue
+    class RecurrenceRule < PropertyValue
+      #- ©2009 Rick DeNatale, All rights reserved. Refer to the file README.txt for the license
+      #
+      module TimeManipulation #:nodoc:
+
+        def advance_day(date_time)
+          date_time.advance(:days => 1)
+        end
+
+        def first_hour_of_day(date_time)
+          date_time.change(:hour => 0)
+        end
+
+        def advance_week(date_time)
+          date_time.advance(:days => 7)
+        end
+
+        def first_day_of_week(wkst_day, date_time)
+          date_time.at_start_of_week_with_wkst(wkst_day)
+        end
+
+        def advance_month(date_time)
+          date_time.advance(:months => 1)
+        end
+
+        def first_day_of_month(date_time)
+          date_time.change(:day => 1)
+        end
+
+        def advance_year(date_time)
+          date_time.advance(:years => 1)
+        end
+
+        def first_day_of_year(date_time)
+          date_time.change(:month => 1, :day => 1)
+        end
+      end
+    end
+  end
+end

data/lib/ri_cal/property_value/recurrence_rule/validations.rb

@@ -0,0 +1,125 @@
+module RiCal
+  class PropertyValue
+    class RecurrenceRule < PropertyValue
+      #- ©2009 Rick DeNatale, All rights reserved. Refer to the file README.txt for the license
+      #
+      module Validations #:nodoc:
+        # Validate that the parameters of the reciever conform to RFC 2445
+        # If errors are found they will be added to the receivers errors
+        #
+        # Whenever any of the parameters are set, e.g. with:
+        #    recurrence_rule.count = 2
+        # the errors will be reset
+        def valid?
+          validate if @errors.nil?
+          errors.empty?
+        end
+
+        # Return any errors found during validation
+        # See #valid?
+        def errors
+          @errors ||= []
+        end
+
+        def reset_errors # :nodoc:
+          @errors = nil
+        end
+
+        # Used by #valid? to validate that the parameters of the reciever conform to RFC 2445
+        # If errors are found they will be added to the receivers errors
+        #
+        # Whenever any of the parameters are set, e.g. with:
+        #    recurrence_rule.count = 2
+        # the errors will be reset
+        def validate
+          @errors = []
+          validate_termination
+          validate_freq
+          validate_interval
+          validate_int_by_list(:bysecond, (0..59))
+          validate_int_by_list(:byminute, (0..59))
+          validate_int_by_list(:byhour, (0..23))
+          validate_int_by_list(:bymonth, (1..12))
+          validate_bysetpos
+          validate_byday_list
+          validate_bymonthday_list
+          validate_byyearday_list
+          validate_byweekno_list
+          validate_wkst
+        end
+
+        def validate_termination
+          errors << "COUNT and UNTIL cannot both be specified" if @count && @until
+        end
+
+        def validate_freq
+          if @freq
+            unless %w{
+              SECONDLY MINUTELY HOURLY DAILY
+              WEEKLY MONTHLY YEARLY
+              }.include?(@freq.upcase)
+              errors <<  "Invalid frequency '#{@freq}'"
+            end
+          else
+            errors << "RecurrenceRule must have a value for FREQ"
+          end
+        end
+
+        def validate_interval
+          if @interval
+            errors << "interval must be a positive integer" unless @interval > 0
+          end
+        end
+
+        def validate_wkst
+          errors << "#{wkst.inspect} is invalid for wkst" unless %w{MO TU WE TH FR SA SU}.include?(wkst)
+        end
+
+        def validate_int_by_list(which, test)
+          vals = by_list[which] || []
+          vals.each do |val|
+            errors << "#{val} is invalid for #{which}" unless test === val
+          end
+        end
+
+        def validate_bysetpos
+          vals = by_list[:bysetpos] || []
+          vals.each do |val|
+            errors << "#{val} is invalid for bysetpos" unless (-366..-1) === val  || (1..366) === val
+          end
+          unless vals.empty?
+            errors << "bysetpos cannot be used without another by_xxx rule part" unless by_list.length > 1
+          end
+        end
+
+        def validate_byday_list
+          days = by_list[:byday] || []
+          days.each do |day|
+            errors << "#{day.source.inspect} is not a valid day" unless day.valid?
+          end
+        end
+
+        def validate_bymonthday_list
+          days = by_list[:bymonthday] || []
+          days.each do |day|
+            errors << "#{day.source.inspect} is not a valid month day" unless day.valid?
+          end
+        end
+
+        def validate_byyearday_list
+          days = by_list[:byyearday] || []
+          days.each do |day|
+            errors << "#{day.source.inspect} is not a valid year day" unless day.valid?
+          end
+        end
+
+        def validate_byweekno_list
+          days = by_list[:byweekno] || []
+          days.each do |day|
+            errors << "#{day.source.inspect} is not a valid week number" unless day.valid?
+          end
+        end
+      end
+    end
+  end
+end