awallis-ri_cal 0.8.8

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

@@ -0,0 +1,38 @@
+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 ByNumberedDayIncrementer < ListIncrementer #:nodoc:
+
+          def daily_incrementer?
+            true
+          end
+          
+          def unneeded?(candidate)
+            list.length == 1 && list.first.fixed_day?
+          end
+
+          def occurrences_for(date_time)
+            if occurrences && @scoping_value == scope_of(date_time)
+               occurrences
+            else
+              @scoping_value = scope_of(date_time)
+              self.occurrences = list.map {|numbered_day| numbered_day.target_date_time_for(date_time)}.uniq.sort
+              occurrences
+            end
+          end
+
+          def end_of_occurrence(date_time)
+            date_time.end_of_day
+          end
+
+          def candidate_acceptable?(candidate)
+            list.any? {|by_part| by_part.include?(candidate)}
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+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 BySecondIncrementer < ListIncrementer #:nodoc:
+
+          def self.for_rrule(rrule)
+            conditional_incrementer(rrule, :bysecond, SecondlyIncrementer)
+          end
+
+          def varying_time_attribute
+            :sec
+          end
+
+          def start_of_cycle(date_time)
+            date_time.start_of_minute
+          end
+
+          def advance_cycle(date_time)
+            date_time.advance(:minutes => 1).start_of_minute
+          end
+
+          def end_of_occurrence(date_time)
+            date_time
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+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 ByWeekNoIncrementer < ListIncrementer #:nodoc:
+          attr_reader :wkst
+          # include WeeklyBydayMethods
+
+          def initialize(rrule, list, sub_cycle_incrementer)
+            @wkst = rrule.wkst_day
+            super(rrule, list, sub_cycle_incrementer)
+          end
+
+          def self.for_rrule(rrule)
+            conditional_incrementer(rrule, :byweekno, WeeklyIncrementer)
+          end
+
+          def weeknum_incrementer?
+            true
+          end
+          
+          def unneeded?(candidate)
+            false
+          end
+
+          def first_within_outer_cycle(previous_occurrence, outer_range)
+            new_range_start = outer_range.first
+            new_range_end = new_range_start.end_of_iso_year(wkst)
+            super(previous_occurrence, outer_range.first..new_range_end)
+          end
+
+          def start_of_cycle(date_time)
+            result = date_time.at_start_of_iso_year(wkst)
+            result
+          end
+
+          def occurrences_for(date_time)
+            iso_year, year_start = *date_time.iso_year_and_week_one_start(wkst)
+            week_one_occurrence = date_time.change(
+              :year => year_start.year,
+              :month => year_start.month,
+              :day => year_start.day
+            )
+            weeks_in_year_plus_one = week_one_occurrence.iso_weeks_in_year(wkst)
+            weeks = list.map {|recurring_weeknum|
+              wk_num = recurring_weeknum.ordinal
+              (wk_num > 0) ? wk_num : weeks_in_year_plus_one + wk_num
+              }.uniq.sort
+            weeks.map {|wk_num| week_one_occurrence.advance(:days => (wk_num - 1) * 7)}
+          end
+
+          def candidate_acceptable?(candidate)
+            list.include?(candidate.iso_week_num(wkst))
+          end
+
+          def advance_cycle(date_time)
+            date_time.at_start_of_next_iso_year(wkst)
+          end
+
+          def end_of_occurrence(date_time)
+            date_time.end_of_week_with_wkst(wkst)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+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 ByYeardayIncrementer < ByNumberedDayIncrementer #:nodoc:
+          def self.for_rrule(rrule)
+            conditional_incrementer(rrule, :byyearday, ByMonthdayIncrementer)
+          end
+
+          def start_of_cycle(date_time)
+            date_time.change(:month => 1, :day => 1)
+          end
+
+          def scope_of(date_time)
+            date_time.year
+          end
+
+          def advance_cycle(date_time)
+            first_day_of_year(advance_year(date_time))
+          end
+
+          def end_of_occurrence(date_time)
+            date_time.end_of_day
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+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 DailyIncrementer < FrequencyIncrementer #:nodoc:
+
+          def self.for_rrule(rrule)
+            conditional_incrementer(rrule, "DAILY", OccurrenceIncrementer::ByHourIncrementer)
+          end
+
+          def daily_incrementer?
+            true
+          end
+
+          def advance_what
+            :days
+          end
+
+          def end_of_occurrence(date_time)
+            date_time.end_of_day
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+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:
+
+        # A FrequenceIncrementer represents the xxxLY and FREQ parts of a recurrence rule
+        # A FrequenceIncrementer has a single occurrence within each cycle.
+        class FrequencyIncrementer < OccurrenceIncrementer #:nodoc:
+          attr_accessor :interval, :outer_occurrence, :skip_increment
+
+          alias_method :cycle_start, :current_occurrence
+
+          def initialize(rrule, sub_cycle_incrementer)
+            super(rrule, sub_cycle_incrementer)
+            self.interval = rrule.interval
+          end
+
+          def self.conditional_incrementer(rrule, freq_str, sub_cycle_class)
+            sub_cycle_incrementer = sub_cycle_class.for_rrule(rrule)
+            if rrule.freq == freq_str
+              new(rrule, sub_cycle_incrementer)
+            else
+              sub_cycle_incrementer
+            end
+          end
+
+          def multiplier
+            1
+          end
+
+          def step(occurrence)
+            occurrence.advance(advance_what => (interval * multiplier))
+          end
+          
+          def sub_cycle_incrementer
+            if @sub_cycle_incrementer.unneeded?(current_occurrence || @previous_occurrence)
+              NullSubCycleIncrementer
+            else
+              super
+            end
+          end
+
+          def first_within_outer_cycle(previous_occurrence, outer_cycle_range)
+            if outer_range
+              first_occurrence = outer_cycle_range.first
+            else
+              first_occurrence = step(previous_occurrence)
+            end
+            self.outer_range = outer_cycle_range
+            sub_cycle_incrementer.first_within_outer_cycle(previous_occurrence, update_cycle_range(first_occurrence))
+          end
+
+          # Advance to the next occurrence, if the result is within the current cycles of all outer incrementers
+          def next_cycle(previous_occurrence)
+            @sub_cycle_dtstart = previous_occurrence
+            if current_occurrence
+              candidate = sub_cycle_incrementer.cycle_adjust(step(current_occurrence))
+            else
+              candidate = step(previous_occurrence)
+            end
+            if outermost?
+              sub_occurrence = sub_cycle_incrementer.first_within_outer_cycle(previous_occurrence, update_cycle_range(candidate))
+              until sub_occurrence
+                candidate = sub_cycle_incrementer.cycle_adjust(step(candidate))
+                sub_occurrence = sub_cycle_incrementer.first_within_outer_cycle(previous_occurrence, update_cycle_range(candidate))
+              end
+              sub_occurrence
+            elsif in_outer_cycle?(candidate)
+              sub_cycle_incrementer.first_within_outer_cycle(previous_occurrence, update_cycle_range(candidate))
+            else
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+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 HourlyIncrementer < FrequencyIncrementer #:nodoc:
+          def self.for_rrule(rrule)
+            conditional_incrementer(rrule, "HOURLY", ByMinuteIncrementer)
+          end
+
+          def advance_what
+            :hours
+          end
+
+          def end_of_occurrence(date_time)
+            date_time.end_of_hour
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+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:
+
+        # A ListIncrementer represents a byxxx part of a recurrence rule
+        # It contains a list of simple values or recurring values
+        # It keeps a collection of occurrences within a given range called a cycle
+        # When the collection of occurrences is exhausted it is refreshed if there is no
+        # outer incrementer, or if a new cycle would start in the current cycle of the outer incrementers.
+        class ListIncrementer < OccurrenceIncrementer #:nodoc:
+          attr_accessor :occurrences, :list, :outer_occurrence, :cycle_start
+
+          def initialize(rrule, list, sub_cycle_incrementer)
+            super(rrule, sub_cycle_incrementer)
+            self.list = list
+          end
+
+          def self.conditional_incrementer(rrule, by_part, sub_cycle_class)
+            sub_cycle_incrementer = sub_cycle_class.for_rrule(rrule)
+            list = rrule.by_rule_list(by_part)
+            if list
+              new(rrule, list, sub_cycle_incrementer)
+            else
+              sub_cycle_incrementer
+            end
+          end
+
+          # Advance to the next occurrence, if the result is within the current cycles of all outer incrementers
+          def next_cycle(previous_occurrence)
+            unless occurrences
+              self.occurrences = occurrences_for(previous_occurrence)
+            end
+            candidate = next_candidate(previous_occurrence)
+            if candidate
+              sub_cycle_incrementer.first_within_outer_cycle(previous_occurrence, update_cycle_range(candidate))
+            else
+              nil
+            end
+          end
+          
+          def unneeded?(candidate)
+            sub_cycle_incrementer.unneeded?(candidate) &&
+            list.length == 1 && 
+            candidate_acceptable?(candidate)
+          end
+          
+          def candidate_acceptable?(candidate)
+            list.any? {|value| candidate.send(varying_time_attribute) == value}
+          end
+
+          def first_within_outer_cycle(previous_occurrence, outer_range)
+            self.outer_range = outer_range
+            self.occurrences = occurrences_within(outer_range)
+            occurrences.each { |occurrence|
+              sub = sub_cycle_incrementer.first_within_outer_cycle(previous_occurrence, update_cycle_range(occurrence))
+              return sub if sub && sub > previous_occurrence
+            }
+            nil
+          end
+
+          def next_candidate(date_time)
+            candidate = next_in_list(date_time)
+            if outermost?
+              while candidate.nil?
+                get_next_occurrences
+                candidate = next_in_list(date_time)
+              end
+            end
+            candidate
+          end
+
+          def next_in_list(date_time)
+            occurrences.find {|occurrence| occurrence > date_time}
+          end
+
+          def get_next_occurrences
+            adv_cycle = advance_cycle(start_of_cycle(occurrences.first))
+            self.occurrences = occurrences_for(adv_cycle)
+          end
+
+          def cycle_adjust(date_time)
+            sub_cycle_incrementer.cycle_adjust(start_of_cycle(date_time))
+          end
+
+          def occurrences_for(date_time)
+            list.map {|value| date_time.change(varying_time_attribute => value)}
+          end
+
+          def occurrences_within(date_time_range)
+            result = []
+            date_time = date_time_range.first
+            while date_time <= date_time_range.last
+               result << occurrences_for(date_time)
+               date_time = advance_cycle(date_time)
+             end
+             result.flatten
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,23 @@
+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 MinutelyIncrementer < FrequencyIncrementer #:nodoc:
+          def self.for_rrule(rrule)
+            conditional_incrementer(rrule, "MINUTELY", BySecondIncrementer)
+          end
+
+          def advance_what
+            :minutes
+          end
+
+          def end_of_occurrence(date_time)
+            date_time.end_of_minute
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ri_cal/property_value/recurrence_rule/occurrence_incrementer/monthly_incrementer.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 OccurrenceIncrementer # :nodoc:
+        class MonthlyIncrementer < FrequencyIncrementer #:nodoc:
+
+          def self.for_rrule(rrule)
+            conditional_incrementer(rrule, "MONTHLY", ByWeekNoIncrementer)
+          end
+
+          def advance_what
+            :months
+          end
+
+          def step(date_time)
+            if contains_daily_incrementer?
+              result = super(date_time).change(:day => 1)
+              result
+            else
+              super(date_time)
+            end
+          end
+
+          def end_of_occurrence(date_time)
+            date_time.end_of_month
+          end
+        end
+      end
+    end
+  end
+end