ri_cal 0.5.0

data/lib/ri_cal/property_value/occurrence_list.rb

@@ -0,0 +1,144 @@
+module RiCal
+  class PropertyValue
+    # OccurrenceList is used to represent the value of an RDATE or EXDATE property.
+    #- ©2009 Rick DeNatale, All rights reserved. Refer to the file README.txt for the license
+    #
+    class OccurrenceList < Array
+      attr_accessor :tzid #:nodoc:
+
+      class Enumerator # :nodoc:
+
+        attr_accessor :default_duration, :occurrence_list
+
+        # TODO: the component parameter should always be the parent
+        def initialize(occurrences, component) # :nodoc:
+          self.occurrence_list = occurrences
+          self.default_duration = component.default_duration
+          @index = 0
+        end
+        
+        def bounded?
+          true
+        end
+        
+        def empty?
+          occurrence_list.empty?
+        end
+
+        def next_occurrence
+          if @index < occurrence_list.length
+            result = occurrence_list[@index].occurrence_period(default_duration)
+            @index += 1
+            result
+          else
+            nil
+          end
+        end
+      end
+
+      def initialize(timezone_finder, options={}) # :nodoc:
+        super
+        validate_elements
+      end
+
+      def self.convert(timezone_finder, *ruby_objects) # :nodoc:
+        # ruby_objects = [ruby_objects] unless Array === ruby_objects
+        source_elements = ruby_objects.inject([]) { |se, element|
+          if String === element
+            element.split(",").each {|str| se << str}
+          else
+            se << element
+          end
+          se
+          }        
+        new(timezone_finder, :source_elements => source_elements )
+      end
+
+      def values_to_elements(values) # :nodoc:
+        values.map {|val| val.to_ri_cal_occurrence_list_value(self)}
+      end
+      
+      def tzid_from_source_elements # :nodoc:
+        if @source_elements && String === (first_source = @source_elements.first)
+          probe = first_source.to_ri_cal_occurrence_list_value rescue nil
+          unless probe
+            return @source_elements.shift
+          end
+        end
+        nil
+      end
+      
+      def tzid_conflict(element_tzid) # :nodoc:
+        element_tzid && tzid != element_tzid
+      end
+      
+      def validate_elements # :nodoc:
+        if @source_elements
+          self.tzid = tzid_from_source_elements
+           @elements = values_to_elements(@source_elements)
+          @value = @elements.map {|prop| prop.value}
+        else
+          @elements = values_to_elements(@value)
+          self.tzid = params['TZID']
+        end
+        # if the tzid wasn't set by the parameters
+        self.tzid ||= @elements.map {|element| element.tzid}.find {|id| id}
+        @elements.each do |element|
+          raise InvalidPropertyValue.new("Mixed timezones are not allowed in an occurrence list") if tzid_conflict(element.tzid)
+          element.tzid = tzid
+        end
+      end
+
+      def has_local_timezone? # :nodoc:
+        tzid && tzid != 'UTC'
+      end
+
+      def visible_params # :nodoc:
+        result = params.dup
+        if has_local_timezone?
+          result['TZID'] = tzid
+        else
+          result.delete('TZID')
+        end
+        result
+      end
+
+      def value # :nodoc:
+        @elements.map {|element| element.value}.join(",")
+      end
+
+      # Return an array of the occurrences within the list
+      def ruby_value
+        @elements.map {|prop| prop.ruby_value}
+      end
+    end
+
+    attr_accessor :elements, :source_elements #:nodoc:
+    private :elements, :elements=, :source_elements=, :source_elements
+
+    def for_parent(parent) #:nodoc:
+      if timezone_finder.nil?
+        @timezone_finder = parent
+        self
+      elsif timezone_finder == parent
+        self
+      else
+        OccurrenceList.new(parent, :value => value)
+      end
+    end
+
+    # Return an enumerator which can produce the elements of the occurrence list
+    def enumerator(component) # :nodoc:
+      OccurrenceList::Enumerator.new(@elements, component)
+    end
+
+    def add_date_times_to(required_timezones) #:nodoc:
+      if @elements
+        @elements.each do | occurrence |
+          occurrence.add_date_times_to(required_timezones)
+        end
+      end
+    end
+
+  end
+end

data/lib/ri_cal/property_value/period.rb

@@ -0,0 +1,82 @@
+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
+      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.rb

@@ -0,0 +1,145 @@
+Dir[File.dirname(__FILE__) + "/recurrence_rule/*.rb"].sort.each do |path|
+  require path
+end
+
+module RiCal
+  class PropertyValue
+    #- ©2009 Rick DeNatale, All rights reserved. Refer to the file README.txt for the license
+    #
+    # RiCal::PropertyValue::RecurrenceRule represents an icalendar Recurrence Rule property value
+    # which is defined in 
+    # rfc 2445 section 4.3.10 pp 40-45
+    class RecurrenceRule < PropertyValue
+      
+      def initialize(parent, value_hash) # :nodoc:
+        @by_list_hash = {}
+        super
+        init_by_lists
+        @by_list_hash = nil
+      end
+      
+      def self.convert(parent, value) #:nodoc:
+        if String === value
+          result = new(parent, :value => value)
+        else
+          result = new(parent, value)
+        end
+        result
+      end
+      
+      include Validations
+      include InitializationMethods
+      include EnumerationSupportMethods
+
+      # The integer count value of the receiver, or nil
+      attr_reader :count
+      # The DATE-TIME value of until limit of the receiver, or nil
+      attr_reader :until
+
+      def value=(string) # :nodoc:
+        if string
+          @value = string
+          dup_hash = {}
+          string.split(";").each do |value_part|
+            initialize_from_value_part(value_part, dup_hash)
+          end
+        end
+      end
+
+      # Set the frequency of the recurrence rule
+      # freq_value:: a String which should be in %w[SECONDLY MINUTELY HOURLY DAILY WEEKLY MONTHLY YEARLY]
+      # 
+      # This method resets the receivers list of errors
+      def freq=(freq_value)
+        reset_errors
+        @freq = freq_value
+      end
+
+      # return the frequency of the rule which will be a string 
+      def freq
+        @freq.upcase
+      end
+
+      # return the starting week day for the recurrence rule, which for a valid instance will be one of
+      # "SU", "MO", "TU", "WE", "TH", "FR", or "SA"
+      def wkst
+        @wkst || 'MO'
+      end
+
+      def wkst_day # :nodoc:
+        @wkst_day ||= (%w{SU MO TU WE FR SA}.index(wkst) || 1)
+      end
+
+      # Set the starting week day for the recurrence rule, which should  be one of
+      # "SU", "MO", "TU", "WE", "TH", "FR", or "SA" for the instance to be valid.
+      # The parameter is however case-insensitive.
+      # 
+      # This method resets the receivers list of errors
+      def wkst=(value)
+        reset_errors
+        @wkst = value
+        @wkst_day = nil
+      end
+
+      # Set the count parameter of the recurrence rule, the count value will be converted to an integer using to_i
+      # 
+      # This method resets the receivers list of errors
+      
+      def count=(count_value)
+        reset_errors
+        @count = count_value
+        @until = nil unless @count.nil? || @by_list_hash
+      end
+
+      # Set the until parameter of the recurrence rule
+      #
+      # until_value:: the value to be set, this may be either a string in RFC 2446 Date or DateTime value format
+      # Or a Date, Time, DateTime, RiCal::PropertyValue::Date, or RiCal::PropertyValue::DateTime
+      #
+      def until=(until_value)
+        reset_errors
+        @until = until_value && until_value.to_ri_cal_date_or_date_time_value(timezone_finder)
+        @count = nil unless @count.nil? || @by_list_hash
+      end
+
+      # return the INTERVAL parameter of the recurrence rule
+      # This returns an Integer
+      def interval
+        @interval ||= 1
+      end
+
+      # Set the INTERVAL parameter of the recurrence rule
+      #
+      # interval_value:: an Integer
+      #
+      # This method resets the receivers list of errors
+      def interval=(interval_value)
+        reset_errors
+        @interval = interval_value
+      end
+      
+      def value #:nodoc:
+        @value || to_ical
+      end      
+
+      # Return a string containing the RFC 2445 representation of the recurrence rule
+      def to_ical
+        result = ["FREQ=#{freq}"]
+        result << "INTERVAL=#{interval}" unless interval == 1
+        result << "COUNT=#{count}" if count
+        result << "UNTIL=#{self.until.value}" if self.until
+        %w{bysecond byminute byhour byday bymonthday byyearday byweekno bymonth bysetpos}.each do |by_part|
+          val = by_list[by_part.to_sym]
+          result << "#{by_part.upcase}=#{[val].flatten.join(',')}" if val
+        end
+        result << "WKST=#{wkst}" unless wkst == "MO"
+        result.join(";")
+      end
+      
+      # Predicate to determine if the receiver generates a bounded or infinite set of occurrences
+      def bounded?
+        @count || @until
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+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
+        
+      end
+    end
+  end
+end