awallis-ri_cal 0.8.8

data/lib/ri_cal/property_value/date_time/additive_methods.rb

@@ -0,0 +1,44 @@
+module RiCal
+  class PropertyValue
+    class DateTime
+      #- ©2009 Rick DeNatale, All rights reserved. Refer to the file README.txt for the license
+      #
+      # Methods for DateTime which support adding or subtracting another DateTime or Duration
+      module AdditiveMethods
+        #  if end_time is nil => nil
+        #  otherwise convert end_time to a DateTime and compute the difference
+        def duration_until(end_time) # :nodoc:
+          end_time  && RiCal::PropertyValue::Duration.from_datetimes(timezone_finder, to_datetime, end_time.to_datetime)
+        end
+
+        # Double-dispatch method for subtraction.
+        def subtract_from_date_time_value(dtvalue) #:nodoc:
+          RiCal::PropertyValue::Duration.from_datetimes(timezone_finder, to_datetime,dtvalue.to_datetime)
+        end
+
+        # Double-dispatch method for addition.
+        def add_to_date_time_value(date_time_value) #:nodoc:
+          raise ArgumentError.new("Cannot add #{date_time_value} to #{self}")
+        end
+
+        # Return the difference between the receiver and other
+        #
+        # The parameter other should be either a RiCal::PropertyValue::Duration or a RiCal::PropertyValue::DateTime
+        #
+        # If other is a Duration, the result will be a DateTime, if it is a DateTime the result will be a Duration
+        def -(other)
+          other.subtract_from_date_time_value(self)
+        end
+
+        # Return the sum of the receiver and duration
+        #
+        # The parameter other duration should be  a RiCal::PropertyValue::Duration
+        #
+        # The result will be an RiCal::PropertyValue::DateTime
+        def +(duration)
+          duration.add_to_date_time_value(self)
+        end
+      end
+    end
+  end
+end

data/lib/ri_cal/property_value/date_time/time_machine.rb

@@ -0,0 +1,159 @@
+module RiCal
+  class PropertyValue
+    class DateTime
+      #- ©2009 Rick DeNatale, All rights reserved. Refer to the file README.txt for the license
+      #
+      # Methods for DateTime which support getting values at different point in time.
+      module TimeMachine
+
+        def advance(options) # :nodoc:
+          PropertyValue::DateTime.new(timezone_finder,
+          :value => @date_time_value.advance(options),
+          :tzid => @tzid,
+          :params =>(params ? params.dup : nil)
+          )
+        end
+
+        def change(options) # :nodoc:
+          PropertyValue::DateTime.new(timezone_finder,
+          :value => @date_time_value.change(options),
+          :tzid => @tzid,
+          :params => (params ? params.dup : nil)
+          )
+        end
+
+        def change_sec(new_sec) #:nodoc:
+          change(:sec => new_sec)
+        end
+
+        def change_min(new_min) #:nodoc:
+          change(:min => new_min)
+        end
+
+        def change_hour(new_hour) #:nodoc:
+          change(:hour => new_hour)
+        end
+
+        def change_day(new_day) #:nodoc:
+          change(:day => new_day)
+        end
+
+        def change_month(new_month) #:nodoc:
+          change(:month => new_month)
+        end
+
+        def change_year(new_year) #:nodoc:
+          change(:year => new_year)
+        end
+
+        # Return a DATE-TIME property representing the receiver on a different day (if necessary) so that
+        # the result is within the 7 days starting with date
+        def in_week_starting?(date)
+          wkst_jd = date.jd
+          @date_time_value.jd.between?(wkst_jd, wkst_jd + 6)
+        end
+
+        # Return a DATE-TIME property representing the receiver on a different day (if necessary) so that
+        # the result is the first day of the ISO week starting on the wkst day containing the receiver.
+        def at_start_of_week_with_wkst(wkst)
+          date = @date_time_value.start_of_week_with_wkst(wkst)
+          change(:year => date.year, :month => date.month, :day => date.day)
+        end
+        # Return a DATE_TIME value representing the first second of the minute containing the receiver
+        def start_of_minute
+          change(:sec => 0)
+        end
+
+        # Return a DATE_TIME value representing the last second of the minute containing the receiver
+        def end_of_minute
+          change(:sec => 59)
+        end
+
+        # Return a DATE_TIME value representing the first second of the hour containing the receiver
+        def start_of_hour
+          change(:min => 0, :sec => 0)
+        end
+
+        # Return a DATE_TIME value representing the last second of the hour containing the receiver
+        def end_of_hour
+          change(:min => 59, :sec => 59)
+        end
+
+        # Return a DATE_TIME value representing the first second of the day containing the receiver
+        def start_of_day
+          change(:hour => 0, :min => 0, :sec => 0)
+        end
+
+        # Return a DATE_TIME value representing the last second of the day containing the receiver
+        def end_of_day
+          change(:hour => 23, :min => 59, :sec => 59)
+        end
+
+        # Return a Ruby Date representing the first day of the ISO week starting with wkst containing the receiver
+        def start_of_week_with_wkst(wkst)
+          @date_time_value.start_of_week_with_wkst(wkst)
+        end
+
+        # Return a DATE_TIME value representing the last second of the ISO week starting with wkst containing the receiver
+        def end_of_week_with_wkst(wkst)
+          date = at_start_of_week_with_wkst(wkst).advance(:days => 6).end_of_day
+        end
+
+        # Return a DATE_TIME value representing the first second of the month containing the receiver
+        def start_of_month
+          change(:day => 1, :hour => 0, :min => 0, :sec => 0)
+        end
+
+        # Return a DATE_TIME value representing the last second of the month containing the receiver
+        def end_of_month
+          change(:day => days_in_month, :hour => 23, :min => 59, :sec => 59)
+        end
+
+        # Return a DATE_TIME value representing the first second of the month containing the receiver
+        def start_of_year
+          change(:month => 1, :day => 1, :hour => 0, :min => 0, :sec => 0)
+        end
+
+        # Return a DATE_TIME value representing the last second of the month containing the receiver
+        def end_of_year
+          change(:month => 12, :day => 31, :hour => 23, :min => 59, :sec => 59)
+        end
+
+        # Return a DATE_TIME value representing the same time on the first day of the ISO year with weeks
+        # starting on wkst containing the receiver
+        def at_start_of_iso_year(wkst)
+          start_of_year = @date_time_value.iso_year_start(wkst)
+          change(:year => start_of_year.year, :month => start_of_year.month, :day => start_of_year.day)
+        end
+
+        # Return a DATE_TIME value representing the same time on the last day of the ISO year with weeks
+        # starting on wkst containing the receiver
+        def at_end_of_iso_year(wkst)
+          num_weeks = @date_time_value.iso_weeks_in_year(wkst)
+          at_start_of_iso_year(wkst).advance(:weeks => (num_weeks - 1), :days => 6)
+        end
+
+        # Return a DATE_TIME value representing the same time on the first day of the ISO year with weeks
+        # starting on wkst after the ISO year containing the receiver
+        def at_start_of_next_iso_year(wkst)
+          num_weeks = @date_time_value.iso_weeks_in_year(wkst)
+          at_start_of_iso_year(wkst).advance(:weeks => num_weeks)
+        end
+
+        # Return a DATE_TIME value representing the last second of the last day of the ISO year with weeks
+        # starting on wkst containing the receiver
+        def end_of_iso_year(wkst)
+          at_end_of_iso_year(wkst).end_of_day
+        end
+
+        # Return a DATE-TIME representing the same time, on the same day of the month in month.
+        # If the month of the receiver has more days than the target month the last day of the target month
+        # will be used.
+        def in_month(month)
+          first = change(:day => 1, :month => month)
+          first.change(:day => [first.days_in_month, day].min)
+        end
+      end
+    end
+  end
+end

data/lib/ri_cal/property_value/date_time/timezone_support.rb

@@ -0,0 +1,100 @@
+module RiCal
+  class PropertyValue
+    class DateTime
+      #- ©2009 Rick DeNatale, All rights reserved. Refer to the file README.txt for the license
+      #
+      # Time zone related methods for DateTime
+      module TimezoneSupport
+        # Return the timezone id of the receiver, or nil if it is a floating time
+        def tzid
+          @tzid  == :floating ? nil : @tzid
+        end
+
+        def tzid=(timezone_id) #:nodoc:
+          timezone_id = default_tzid if timezone_id == :default
+          @tzid = timezone_id
+          reset_cached_values
+        end
+
+        def reset_cached_values #:nodoc:
+          @timezone = @utc = @rational_tz_offset = nil
+        end
+
+        def find_timezone #:nodoc:
+          if @tzid == :floating
+            FloatingTimezone
+          else
+            timezone_finder.find_timezone(@tzid)
+          end
+        end
+
+        def timezone #:nodoc:
+          @timezone ||= find_timezone
+        end
+
+        # Determine if the receiver has a local time zone, i.e. it is not a floating time or a UTC time
+        def has_local_timezone?
+          tzid && tzid.upcase != "UTC"
+        end
+
+        # Return the receiver if it has a floating time zone already,
+        # otherwise return a DATETIME property with the same time as the receiver but with a floating time zone
+        def with_floating_timezone
+          if @tzid == nil
+            self
+          else
+            @date_time_value.with_floating_timezone.to_ri_cal_date_time_value
+          end
+        end
+
+        # Returns a instance that represents the time in UTC.
+        def utc
+          if has_local_timezone?
+            @utc ||= timezone.local_to_utc(self)
+          else  # Already local or a floating time
+            self
+          end
+        end
+
+        def rational_tz_offset #:nodoc:
+          if has_local_timezone?
+            @rational_tz_offset ||= timezone.rational_utc_offset(@date_time_value.to_datetime)
+          else
+            @rational_tz_offset ||= RiCal.RationalOffset[0]
+          end
+        end
+
+        # Predicate indicating whether or not the instance represents a ZULU time
+        def utc?
+          tzid == "UTC"
+        end
+
+        # Predicate indicating whether or not the instance represents a floating time
+        def floating?
+          tzid.nil?
+        end
+
+        def has_valid_tzinfo_tzid? #:nodoc:
+          if tzid && tzid != :floating
+            TZInfo::Timezone.get(tzid) rescue false
+          else
+            false
+          end
+        end
+
+        # Returns the simultaneous time in the specified zone.
+        def in_time_zone(new_zone)
+          new_zone = timezone_finder.find_timezone(new_zone)
+          return self if tzid == new_zone.identifier
+          if has_local_timezone?
+            new_zone.utc_to_local(utc)
+          elsif utc?
+            new_zone.utc_to_local(self)
+          else # Floating time
+            DateTime.new(timezone_finder, :value => @date_time_value, :tzid => new_zone.identifier)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ri_cal/property_value/duration.rb

@@ -0,0 +1,110 @@
+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 Duration property value
+    # which is defined in 
+    # rfc 2445 section 4.3.6 p 37
+    class Duration < PropertyValue
+
+      def self.value_part(unit, diff) # :nodoc:
+        (diff == 0) ? nil : "#{diff}#{unit}"
+      end
+
+      def self.from_datetimes(parent, start, finish, sign='+') # :nodoc:
+        if start > finish
+          from_datetimes(self, finish, start, '-')
+        else
+          diff = finish - start
+          days_diff = diff.to_i
+          hours = (diff - days_diff) * 24
+          hour_diff = hours.to_i
+          minutes = (hours - hour_diff) * 60
+          min_diff = minutes.to_i
+          seconds = (minutes - min_diff) * 60
+          sec_diff = seconds.to_i
+
+          day_part = value_part('D',days_diff)
+          hour_part = value_part('H', hour_diff)
+          min_part = value_part('M', min_diff)
+          sec_part = value_part('S', sec_diff)
+          t_part = (hour_diff.abs + min_diff.abs + sec_diff.abs) == 0 ? "" : "T"
+          new(parent, :value => "#{sign}P#{day_part}#{t_part}#{hour_part}#{min_part}#{sec_part}")        
+        end
+      end
+
+      def self.convert(parent, ruby_object) # :nodoc:
+        ruby_object.to_ri_cal_duration_value
+      end
+
+      def value=(string) # :nodoc:
+        super
+        match = /([+-])?P(.*)$/.match(string)
+        @days = @hours = @minutes = @seconds = @weeks = 0
+        if match
+          @sign = match[1] == '-' ? -1 : 1
+          match[2].scan(/(\d+)([DHMSW])/) do |digits, unit|
+            number = digits.to_i
+            case unit
+            when 'D'
+              @days = number
+            when 'H'
+              @hours = number
+            when 'M'
+              @minutes = number
+            when 'S'
+              @seconds = number
+            when 'W'
+              @weeks = number
+            end
+          end
+        end
+      end
+      
+      def self.valid_string?(string) #:nodoc:
+        string =~  /^[+-]?P((\d+D)(T((\d+)[HMS])+)?)|(T((\d+)[HMS])+)|(\d+W)$/
+      end
+
+      def days # :nodoc:
+        @days * @sign
+      end
+
+      def weeks # :nodoc:
+        @weeks * @sign
+      end
+
+      def hours # :nodoc:
+        @hours * @sign
+      end
+
+      def minutes # :nodoc:
+        @minutes * @sign
+      end
+
+      def seconds # :nodoc:
+        @seconds * @sign
+      end
+
+      # Determine whether another object is an equivalent RiCal::PropertyValue::Duration
+      def ==(other)
+        other.kind_of?(PropertyValue::Duration) && value == other.value
+      end
+
+      # Returns the receiver
+      def to_ri_cal_duration_value
+        self
+      end
+
+      # Double-dispatch method to support RiCal::PropertyValue::DateTime.-
+      def subtract_from_date_time_value(date_time_value)
+        date_time_value.advance(:weeks => -weeks, :days => -days, :hours => -hours, :minutes => -minutes, :seconds => -seconds)
+      end
+
+      # Double-dispatch method to support RiCal::PropertyValue::DateTime.+
+      def add_to_date_time_value(date_time_value)
+        date_time_value.advance(:weeks => weeks, :days => days, :hours => hours, :minutes => minutes, :seconds => seconds)
+      end
+
+    end
+  end
+end

data/lib/ri_cal/property_value/geo.rb

@@ -0,0 +1,11 @@
+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 Duration property value
+    # which is defined in 
+    # rfc 2445 section 4.8.1.6 pp 82-83
+    class Geo < PropertyValue
+    end
+  end
+end

data/lib/ri_cal/property_value/integer.rb

@@ -0,0 +1,12 @@
+module RiCal
+  class PropertyValue
+    #- ©2009 Rick DeNatale, All rights reserved. Refer to the file README.txt for the license
+    #
+    class Integer < PropertyValue # :nodoc:
+
+      def value=(string)
+        @value = string.to_i 
+      end
+    end
+  end
+end

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