ri_cal 0.5.0

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

@@ -0,0 +1,79 @@
+module RiCal
+  class PropertyValue
+    class RecurrenceRule < PropertyValue
+      #- ©2009 Rick DeNatale, All rights reserved. Refer to the file README.txt for the license
+      #
+      class Enumerator # :nodoc:
+        # 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
+          @next_occurrence_count = 0
+          @incrementer = YearlyIncrementer.from_rrule(recurrence_rule, start_time)
+        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, component, setpos_list)
+          end
+        end
+
+         def empty?
+          false
+        end
+
+        def bounded?
+          @bounded
+        end
+
+        def result_occurrence_period(date_time_value)
+          RiCal::OccurrencePeriod.new(date_time_value, nil)
+        end
+
+        def result_passes_setpos_filter?(result)
+          result_setpos = @setpos
+          if recurrence_rule.in_same_set?(result, next_time)
+            @setpos += 1
+          else
+            @setpos = 1
+          end
+          if (result == start_time) || (result > start_time && @setpos_list.include?(result_setpos))
+            return true
+          else
+            return false
+          end
+        end
+
+        def result_passes_filters?(result)
+          if @setpos_list
+            result_passes_setpos_filter?(result)
+          else
+            result >= start_time
+          end
+        end
+
+        def next_occurrence
+          while true
+            @next_occurrence_count += 1
+            result = next_time
+            self.next_time = @incrementer.next_time(result)
+            if result_passes_filters?(result)
+              @count += 1
+              return recurrence_rule.exhausted?(@count, result) ? nil : result_occurrence_period(result)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+module RiCal
+  class PropertyValue
+    class RecurrenceRule < PropertyValue
+      #- ©2009 Rick DeNatale, All rights reserved. Refer to the file README.txt for the license
+      #
+      module InitializationMethods # :nodoc:
+        
+        attr_reader :by_day_scope
+        
+        def add_to_options_hash(options_hash, key, value)
+          options_hash[key] = value if value
+          options_hash
+        end
+        
+        def add_byrule_strings_to_options_hash(options_hash, key)
+          if (rules = by_list[key])
+            if rules.length = 1
+              options_hash[key] = rules.first.source
+            else
+              options_hash[key] = rules.map {|rule| rule.source}
+            end
+          end
+        end
+        
+        def to_options_hash
+          options_hash = {:freq => freq, :interval => interval}
+          options_hash[:params] = params unless params.empty?
+          add_to_options_hash(options_hash, :count, @count)
+          add_to_options_hash(options_hash, :until, @until)
+          add_to_options_hash(options_hash, :interval, @interval)
+          [:bysecond, :byminute, :byhour, :bymonth, :bysetpos].each do |bypart|
+              add_to_options_hash(options_hash, bypart, by_list[bypart])
+            end
+          [:byday, :bymonthday, :byyearday, :byweekno].each do |bypart|
+             add_byrule_strings_to_options_hash(options_hash, bypart)
+          end
+          options_hash
+        end
+
+        def initialize_from_value_part(part, dup_hash) # :nodoc:
+          part_name, value = part.split("=")
+          attribute = part_name.downcase
+          errors << "Repeated rule part #{attribute} last occurrence was used" if dup_hash[attribute]
+          case attribute
+          when "freq"
+            self.freq = value
+          when "wkst"
+            self.wkst = value
+          when "until"
+            @until = PropertyValue.date_or_date_time(self, :value => value)
+          when "count"
+            @count = value.to_i
+          when "interval"
+            self.interval = value.to_i
+          when "bysecond", "byminute", "byhour", "bymonthday", "byyearday", "byweekno", "bymonth", "bysetpos"
+            send("#{attribute}=", value.split(",").map {|int| int.to_i})
+          when "byday"
+            self.byday = value.split(",")
+          else
+            errors << "Invalid rule part #{part}"
+          end
+        end
+
+        def by_list
+          @by_list ||= {}
+        end
+        
+        def calc_by_day_scope
+          case freq
+          when "YEARLY"
+            scope = :yearly
+          when "MONTHLY"
+            scope = :monthly
+          when "WEEKLY"
+            scope = :weekly
+          else
+            scope = :daily
+          end
+          scope = :monthly if scope != :weekly && @by_list_hash[:bymonth]
+          scope = :weekly if scope != :daily && @by_list_hash[:byweekno]
+          @by_day_scope = scope
+        end
+        
+        def bysecond=(val)
+          @by_list_hash[:bysecond] = val
+        end
+
+        def byminute=(val)
+          @by_list_hash[:byminute] = val
+        end
+
+        def byhour=(val)
+          @by_list_hash[:byhour] = val
+        end
+
+        def bymonth=(val)
+          @by_list_hash[:bymonth] = val
+        end
+
+        def bysetpos=(val)
+          @by_list_hash[:bysetpos] = val
+        end
+
+        def byday=(val)
+          @by_list_hash[:byday] = val
+        end
+
+        def bymonthday=(val)
+          @by_list_hash[:bymonthday] = val
+        end
+
+        def byyearday=(val)
+          @by_list_hash[:byyearday] = val
+        end
+
+        def byweekno=(val)
+          @by_list_hash[:byweekno] = val
+        end
+
+        def init_by_lists
+          [:bysecond,
+            :byminute,
+            :byhour,
+            :bymonth,
+            :bysetpos
+            ].each do |which|
+              if val = @by_list_hash[which]
+                by_list[which] = [val].flatten.sort
+              end
+            end
+            if val = @by_list_hash[:byday]
+              byday_scope =  calc_by_day_scope 
+              by_list[:byday] = [val].flatten.map {|day| RecurringDay.new(day, self, byday_scope)}
+            end
+            if val = @by_list_hash[:bymonthday]
+              by_list[:bymonthday] = [val].flatten.map {|md| RecurringMonthDay.new(md)}
+            end
+            if val = @by_list_hash[:byyearday]
+              by_list[:byyearday] = [val].flatten.map {|yd| RecurringYearDay.new(yd)}
+            end
+            if val = @by_list_hash[:byweekno]
+              by_list[:byweekno] = [val].flatten.map {|wkno| RecurringNumberedWeek.new(wkno, self)}
+            end
+          end
+        end
+      end
+    end
+  end

data/lib/ri_cal/property_value/recurrence_rule/negative_setpos_enumerator.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 NegativeSetposEnumerator < Enumerator # :nodoc:
+
+        def initialize(recurrence_rule, component, setpos_list)
+          super
+          @current_set = []
+          @valids = []
+        end
+
+        def next_occurrence
+          while true
+            result = advance
+            if result >= start_time
+              @count += 1
+              return recurrence_rule.exhausted?(@count, result) ? nil : result_occurrence_period(result)
+            end
+          end
+        end
+        
+        
+
+        def advance
+          if @valids.empty?
+            fill_set
+            @valids = @setpos_list.map {|sp| sp < 0 ? @current_set.length + sp : sp - 1}
+            current_time_index = @current_set.index(@start_time)
+            if current_time_index
+              @valids << current_time_index
+            end
+            @valids = @valids.uniq.sort
+          end
+          @current_set[@valids.shift]
+        end
+
+        def fill_set
+          @current_set = [next_time]
+          while true
+            self.next_time = @incrementer.next_time(next_time)
+            if recurrence_rule.in_same_set?(@current_set.last, next_time)
+              @current_set << next_time
+            else
+              return
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ri_cal/property_value/recurrence_rule/numbered_span.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 NumberedSpan # :nodoc:
+        attr_reader :source
+        def initialize(source, rule = nil)
+          @source = source
+          @rule = rule
+        end
+
+        def valid?
+          (1..last).include?(source) || (-last..-1).include?(source)
+        end
+
+        def  ==(another)
+          self.class == another.class && source == another.source
+        end
+
+        def to_s
+          source.to_s
+        end
+        
+        def ordinal
+          @source
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,793 @@
+module RiCal
+  class PropertyValue
+    class RecurrenceRule < PropertyValue
+      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
+      #- ©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
+
+        include TimeManipulation
+
+        class NullSubCycleIncrementer #:nodoc:
+          def self.next_time(previous)
+            nil
+          end
+
+          def self.add_outer_incrementer(incrementer)
+          end
+
+          def self.first_within_outer_cycle(previous_occurrence, outer_cycle_range)
+            outer_cycle_range.first
+          end
+
+          def self.first_sub_occurrence(previous_occurrence, outer_cycle_range)
+            nil
+          end
+
+          def self.cycle_adjust(date_time)
+            date_time
+          end
+
+          def self.to_s
+            "NULL-INCR"
+          end
+
+          def inspect
+            to_s
+          end
+        end
+
+        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 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)
+          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
+
+      # 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 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
+
+      # 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 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)
+          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
+
+      class SecondlyIncrementer < FrequencyIncrementer #:nodoc:
+
+        def self.for_rrule(rrule)
+          if rrule.freq == "SECONDLY"
+            new(rrule, nil)
+          else
+            nil
+          end
+        end
+
+        def advance_what
+          :seconds
+        end
+
+        def end_of_occurrence(date_time)
+          date_time
+        end
+      end
+
+
+      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
+
+      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
+
+      class ByMinuteIncrementer < ListIncrementer #:nodoc:
+        def self.for_rrule(rrule)
+          conditional_incrementer(rrule, :byminute, MinutelyIncrementer)
+        end
+
+        def advance_cycle(date_time)
+          date_time.advance(:hours => 1).start_of_hour
+        end
+
+        def start_of_cycle(date_time)
+          date_time.change(:min => 0)
+        end
+
+        def end_of_occurrence(date_time)
+          date_time.end_of_minute
+        end
+
+        def varying_time_attribute
+          :min
+        end
+      end
+
+      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
+
+      class ByHourIncrementer < ListIncrementer #:nodoc:
+        def self.for_rrule(rrule)
+          conditional_incrementer(rrule, :byhour, HourlyIncrementer)
+        end
+
+        def start_of_cycle(date_time)
+          date_time.change(:hour => 0)
+        end
+
+        def varying_time_attribute
+          :hour
+        end
+
+        def advance_cycle(date_time)
+          first_hour_of_day(advance_day(date_time))
+        end
+
+        def end_of_occurrence(date_time)
+          date_time.end_of_hour
+        end
+      end
+
+      class DailyIncrementer < FrequencyIncrementer #:nodoc:
+
+        def self.for_rrule(rrule)
+          conditional_incrementer(rrule, "DAILY", 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
+
+      class ByNumberedDayIncrementer < ListIncrementer #:nodoc:
+
+        def daily_incrementer?
+          true
+        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_acceptible?(candidate)
+          list.any? {|by_part| by_part.include?(candidate)}
+        end
+      end
+
+      class ByMonthdayIncrementer < ByNumberedDayIncrementer #:nodoc:
+        def self.for_rrule(rrule)
+          conditional_incrementer(rrule, :bymonthday, DailyIncrementer)
+        end
+
+        def scope_of(date_time)
+          date_time.month
+        end
+
+        def start_of_cycle(date_time)
+          date_time.change(:day => 1)
+        end
+
+        def advance_cycle(date_time)
+          first_day_of_month(advance_month(date_time))
+        end
+
+        def end_of_occurrence(date_time)
+          date_time.end_of_day
+        end
+      end
+
+      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
+
+      class ByDayIncrementer < ListIncrementer #:nodoc:
+
+        def initialize(rrule, list, by_monthday_list, by_yearday_list, parent)
+          super(rrule, list, parent)
+          @monthday_filters = by_monthday_list
+          @yearday_filters = by_yearday_list
+          @by_day_scope = rrule.by_day_scope
+
+          case rrule.by_day_scope
+          when :yearly
+            @cycle_advance_proc = lambda {|date_time| first_day_of_year(advance_year(date_time))}
+            @current_proc = lambda {|date_time| same_year?(current, date_time)}
+            @first_day_proc = lambda {|date_time| first_day_of_year(date_time)}
+          when :monthly
+            @cycle_advance_proc = lambda {|date_time| first_day_of_month(advance_month(date_time))}
+            @current_proc = lambda {|date_time| same_month?(current, date_time)}
+            @first_day_proc = lambda {|date_time| first_day_of_month(date_time)}
+          when :weekly
+            @cycle_advance_proc = lambda {|date_time| first_day_of_week(rrule.wkst_day, advance_week(date_time))}
+            @current_proc = lambda {|date_time| same_week?(rrule.wkst_day, current, date_time)}
+            @first_day_proc = lambda {|date_time| first_day_of_week(rrule.wkst_day, date_time)}
+          else
+            raise "Invalid recurrence rule, byday needs to be scoped by month, week or year"
+          end
+        end
+
+        def self.for_rrule(rrule)
+          list = rrule.by_rule_list(:byday)
+          if list
+            sub_cycle_incrementer = DailyIncrementer.for_rrule(rrule)
+            new(rrule, list, rrule.by_rule_list(:bymonthday), rrule.by_rule_list(:byyearday), sub_cycle_incrementer)
+          else
+            ByYeardayIncrementer.for_rrule(rrule)
+          end
+        end
+
+        def daily_incrementer?
+          true
+        end
+
+        def start_of_cycle(date_time)
+          @first_day_proc.call(date_time)
+        end
+
+        def occurrences_for(date_time)
+          first_day = start_of_cycle(date_time)
+          result = list.map {|recurring_day| recurring_day.matches_for(first_day)}.flatten.uniq.sort
+          if @monthday_filters
+            result = result.select {|occurrence| @monthday_filters.any? {|recurring_day| recurring_day.include?(occurrence)}}
+          end
+          if @yearday_filters
+            result = result.select {|occurrence| @yearday_filters.any? {|recurring_day| recurring_day.include?(occurrence)}}
+          end
+          result
+        end
+
+        def candidate_acceptible?(candidate)
+          list.any? {|recurring_day| recurring_day.include?(candidate)}
+        end
+
+        def varying_time_attribute
+          :day
+        end
+
+        def advance_cycle(date_time)
+          @cycle_advance_proc.call(date_time)
+        end
+
+        def end_of_occurrence(date_time)
+          date_time.end_of_day
+        end
+      end
+
+      class WeeklyIncrementer < FrequencyIncrementer #:nodoc:
+
+        attr_reader :wkst
+
+        # include WeeklyBydayMethods
+
+        def initialize(rrule, parent)
+          @wkst = rrule.wkst_day
+          super(rrule, parent)
+        end
+
+        def self.for_rrule(rrule)
+          conditional_incrementer(rrule, "WEEKLY", ByDayIncrementer)
+        end
+
+        def multiplier
+          7
+        end
+
+        def advance_what
+          :days
+        end
+
+        def end_of_occurrence(date_time)
+          date_time.end_of_week_with_wkst(wkst)
+        end
+      end
+
+      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 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_acceptible?(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
+
+      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
+
+      class ByMonthIncrementer < ListIncrementer #:nodoc:
+
+        def self.for_rrule(rrule)
+          conditional_incrementer(rrule, :bymonth, MonthlyIncrementer)
+        end
+
+        def occurrences_for(date_time)
+          if contains_daily_incrementer?
+            list.map {|value| date_time.change(:month => value, :day => 1)}
+          else
+            list.map {|value| date_time.in_month(value)}
+          end
+        end
+
+        def range_advance(date_time)
+          advance_year(date_time)
+        end
+
+        def start_of_cycle(date_time)
+          if contains_daily_incrementer?
+            date_time.change(:month => 1, :day => 1)
+          else
+            date_time.change(:month => 1)
+          end
+        end
+
+        def varying_time_attribute
+          :month
+        end
+
+        def advance_cycle(date_time)
+          if contains_daily_incrementer?
+            first_day_of_year(advance_year(date_time))
+          else
+            advance_year(date_time).change(:month => 1)
+          end
+        end
+
+        def end_of_occurrence(date_time)
+          date_time.end_of_month
+        end
+      end
+
+      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