micahwedemeyer-ri_cal 0.8.9

data/lib/ri_cal/property_value/period.rb

@@ -0,0 +1,86 @@
+module RiCal
+  class PropertyValue
+    #- ©2009 Rick DeNatale, All rights reserved. Refer to the file README.txt for the license
+    #
+    # RiCal::PropertyValue::CalAddress represents an icalendar Period property value
+    # which is defined in 
+    # rfc 2445 section 4.3.9 p 39
+    #
+    # Known bugs.  This doesn't properly work when dtstart, dtend or duration are changed independently
+    class Period < PropertyValue
+
+      # The DATE-TIME on which the period starts
+      attr_accessor :dtstart
+      # The DATE-TIME on which the period ends
+      attr_accessor :dtend
+      # The DURATION of the period
+      attr_accessor :duration
+
+      def value=(string) # :nodoc:
+        starter, terminator = *string.split("/")
+        self.dtstart = PropertyValue::DateTime.new(self, :value => starter)
+        if /P/ =~ terminator
+          self.duration = PropertyValue::Duration.new(self, :value => terminator)
+          self.dtend = dtstart + duration
+        else
+          self.dtend   = PropertyValue::DateTime.new(self, :value => terminator)
+          self.duration = PropertyValue::Duration.from_datetimes(self, dtstart.to_datetime, dtend.to_datetime)        
+        end
+        @value = string
+      end
+      
+      def ruby_value
+        self
+      end
+      
+      def self.valid_string?(string) # :nodoc:
+        return false unless string.include?("/")
+        starter, terminator = *string.split("/")
+        return false unless PropertyValue::DateTime.valid_string?(starter)
+        if /P/ =~ terminator
+          return false unless PropertyValue::Duration.valid_string?(terminator)
+        else
+          return false unless PropertyValue::DateTime.valid_string?(terminator)
+        end
+        true
+      end
+      
+      # Nop to allow occurrence list to try to set it
+      def tzid=(val)#:nodoc:
+      end
+      
+      def tzid #:nodoc:
+        nil
+      end
+      
+      def for_parent(parent) #:nodoc:
+        if timezone_finder.nil
+          @timezone_finder = parent
+          self
+        elsif timezone_finder == parent
+          self
+        else
+          Period.new(parent, :value => value)
+        end
+      end
+      
+      def self.convert(parent, ruby_object) # :nodoc:
+        ruby_object.to_ri_cal_period_value.for_parent(parent)
+      end
+
+      # return the receiver
+      def to_ri_cal_period_value
+        self
+      end
+
+      def occurrence_period(default_duration) #:nodoc:
+        RiCal::OccurrencePeriod.new(self, (default_duration ? self + default_duration : nil))
+      end
+
+      def add_date_times_to(required_timezones) #:nodoc:
+        dtstart.add_date_times_to(required_timezones)
+        dtend.add_date_times_to(required_timezones)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+module RiCal
+  class PropertyValue
+    class RecurrenceRule < PropertyValue
+      #- ©2009 Rick DeNatale, All rights reserved. Refer to the file README.txt for the license
+      #
+      module EnumerationSupportMethods # :nodoc:
+
+        # 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
+
+        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 by_rule_list(which) # :nodoc:
+          if @by_list
+            @by_list[which]
+          else
+            nil
+          end
+        end
+
+        def incrementer_from_start_time(start_time)
+          RecurrenceRule::OccurrenceIncrementer.from_rrule(self, start_time)
+        end
+      end
+    end
+  end
+end

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 = recurrence_rule.incrementer_from_start_time(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/occurrence_incrementer/by_day_incrementer.rb

@@ -0,0 +1,86 @@
+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 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 = OccurrenceIncrementer::DailyIncrementer.for_rrule(rrule)
+              new(rrule, list, rrule.by_rule_list(:bymonthday), rrule.by_rule_list(:byyearday), sub_cycle_incrementer)
+            else
+              OccurrenceIncrementer::ByYeardayIncrementer.for_rrule(rrule)
+            end
+          end
+          
+          def unneeded?(candidate)
+            false
+          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_acceptable?(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
+      end
+    end
+  end
+end

data/lib/ri_cal/property_value/recurrence_rule/occurrence_incrementer/by_hour_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 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
+      end
+    end
+  end
+end

data/lib/ri_cal/property_value/recurrence_rule/occurrence_incrementer/by_minute_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 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
+
+      end
+    end
+  end
+end