demingfactor-ri_cal 0.9.0

data/lib/ri_cal/property_value/date_time.rb

@@ -0,0 +1,359 @@
+require 'date'
+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 CalAddress property value
+    # which is defined in RFC 2445 section 4.3.5 pp 35-37
+    class DateTime < PropertyValue
+
+      Dir[File.dirname(__FILE__) + "/date_time/*.rb"].sort.each do |path|
+        require path
+      end
+
+      include Comparable
+      include AdditiveMethods
+      include TimezoneSupport
+      include TimeMachine
+
+      def self.or_date(parent, line) # :nodoc:
+        if /T/.match(line[:value] || "")
+          new(parent, line)
+        else
+          PropertyValue::Date.new(parent, line)
+        end
+      end
+      
+      def self.valid_string?(string) #:nodoc:
+        string =~ /^\d{8}T\d{6}Z?$/
+      end
+
+      def self.default_tzid # :nodoc:
+        @default_tzid ||= "UTC"
+      end
+
+      def self.params_for_tzid(tzid) #:nodoc:
+        if tzid == :floating
+          {}
+        else
+          {'TZID' => tzid}
+        end
+      end
+
+      # Set the default tzid to be used when instantiating an instance from a ruby object
+      # see RiCal::PropertyValue::DateTime.from_time
+      #
+      # The parameter tzid is a string value to be used for the default tzid, a value of :floating will cause
+      # values with NO timezone to be produced, which will be interpreted by iCalendar as floating times
+      # i.e. they are interpreted in the timezone of each client. Floating times are typically used
+      # to represent events which are 'repeated' in the various time zones, like the first hour of the year.
+      def self.default_tzid=(tzid)
+        @default_tzid = tzid
+      end
+
+      def self.default_tzid_hash # :nodoc:
+        if default_tzid.to_s == 'none'
+          {}
+        else
+          {'TZID' => default_tzid}
+        end
+      end
+      
+      def inspect # :nodoc:
+        "#{@date_time_value}:#{tzid}"
+      end
+
+      # Returns the value of the receiver as an RFC 2445 iCalendar string
+      def value
+        if @date_time_value
+          "#{@date_time_value.ical_str}#{tzid == "UTC" ? "Z" : ""}"
+        else
+          nil
+        end
+      end
+      
+      def to_ri_cal_zulu_date_time
+        ZuluDateTime.new(nil, :value => self.utc.fast_date_tme)
+      end
+      
+      def fast_date_tme # :nodoc:
+        @date_time_value
+      end
+
+      # Set the value of the property to val
+      #
+      # val may be either:
+      #
+      # * A string which can be parsed as a DateTime
+      # * A Time instance
+      # * A Date instance
+      # * A DateTime instance
+      def value=(val) # :nodoc:
+        case val
+        when nil
+          @date_time_value = nil
+        when String
+          @date_time_value = FastDateTime.from_date_time(::DateTime.parse(val))
+          if val =~/Z/
+            self.tzid = 'UTC'
+          else
+            @tzid ||= :floating
+          end
+        when FastDateTime
+          @date_time_value = val
+        when ::DateTime
+          @date_time_value = FastDateTime.from_date_time(val)
+        when ::Date, ::Time
+          @date_time_value = FastDateTime.from_date_time(::DateTime.parse(val.to_s))
+        end
+        reset_cached_values
+      end
+      
+      # Extract the time and timezone identifier from an object used to set the value of a DATETIME property.
+      #
+      # If the object is a string it should be of the form [TZID=identifier:]
+      #
+      # Otherwise determine if the object acts like an activesupport enhanced time, and extract its timezone
+      # idenfifier if it has one.
+      #
+      def self.time_and_parameters(object)
+        parameters = {}
+        if ::String === object
+          object, parameters = self.time_and_parameters_from_string(object)
+        else
+          identifier = object.tzid rescue nil
+          parameters["TZID"] = identifier if identifier
+        end
+        [object, parameters]
+      end
+
+
+      def self.convert(timezone_finder, ruby_object) # :nodoc:
+          ruby_object.to_ri_cal_date_or_date_time_value(timezone_finder)
+      end
+
+      def self.from_string(string) # :nodoc:
+        if string.match(/Z$/)
+          new(nil, :value => string, :tzid => 'UTC')
+        else
+          new(nil, :value => string)
+        end
+      end
+
+      def for_parent(parent) #:nodoc:
+        if timezone_finder.nil?
+          @timezone_finder = parent
+          self
+        elsif parent == timezone_finder
+          self
+        else
+          DateTime.new(parent, :value => @date_time_value, :params => params, :tzid => tzid)
+        end
+      end
+
+      def visible_params # :nodoc:
+        result = {"VALUE" => "DATE-TIME"}.merge(params)
+        if has_local_timezone?
+          result['TZID'] = tzid
+        else
+          result.delete('TZID')
+        end
+        result
+      end
+
+      def params=(value) #:nodoc:
+        @params = value.dup
+        if params_timezone = @params['TZID']
+          self.tzid =  @params['TZID']
+        end
+      end
+      
+      # Return a Hash representing this properties parameters
+      def params
+        result = @params.dup
+        case tzid
+        when :floating, nil, "UTC"
+          result.delete('TZID')
+        else
+          result['TZID'] = tzid
+        end
+        result
+      end
+
+      # Compare the receiver with another object which must respond to the to_datetime message
+      # The comparison is done using the Ruby DateTime representations of the two objects
+      def <=>(other)
+       other.cmp_fast_date_time_value(@date_time_value)
+      end
+      
+      def cmp_fast_date_time_value(other)
+        other <=> @date_time_value
+      end
+
+      # Determine if the receiver and other are in the same month
+      def in_same_month_as?(other)
+        [other.year, other.month] == [year, month]
+      end
+
+      def with_date_time_value(date_time_value)
+        PropertyValue::DateTime.new(
+          timezone_finder,
+          :value => date_time_value,
+          :params => (params),
+          :tzid => tzid
+        )
+      end
+      
+      def nth_wday_in_month(n, which_wday) #:nodoc:
+        with_date_time_value(@date_time_value.nth_wday_in_month(n, which_wday))
+      end
+
+      def nth_wday_in_year(n, which_wday) #:nodoc:
+        with_date_time_value(@date_time_value.nth_wday_in_year(n, which_wday))
+      end
+
+      def self.civil(year, month, day, hour, min, sec, offset, start, params) #:nodoc:
+        PropertyValue::DateTime.new(
+           :value => ::DateTime.civil(year, month, day, hour, min, sec, offset, start),
+           :params =>(params ? params.dup : nil)
+        )
+      end
+
+      # Return the number of days in the month containing the receiver
+      def days_in_month
+        @date_time_value.days_in_month
+      end
+
+      # Determine if the receiver and another object are equivalent RiCal::PropertyValue::DateTime instances
+      def ==(other)
+        if self.class === other
+          self.value == other.value && self.visible_params == other.visible_params && self.tzid == other.tzid
+        else
+          super
+        end
+      end
+
+      # TODO: consider if this should be a period rather than a hash
+      def occurrence_period(default_duration) # :nodoc:
+        RiCal::OccurrencePeriod.new(self, (default_duration ? self + default_duration : nil))
+      end
+
+      # Return the year (including the century)
+      def year
+        @date_time_value.year
+      end
+
+      # Return the month of the year (1..12)
+      def month
+        @date_time_value.month
+      end
+
+      # Return the day of the month
+      def day
+        @date_time_value.day
+      end
+
+      alias_method :mday, :day
+
+      # Return the day of the week
+      def wday
+        @date_time_value.wday
+      end
+
+      # Return the hour
+      def hour
+        @date_time_value.hour
+      end
+
+      # Return the minute
+      def min
+        @date_time_value.min
+      end
+
+       # Return the second
+      def sec
+        @date_time_value.sec
+      end
+
+
+      # Return an RiCal::PropertyValue::DateTime representing the receiver.
+      def to_ri_cal_date_time_value(timezone=nil)
+        for_parent(timezone)
+      end
+
+      def iso_year_and_week_one_start(wkst) #:nodoc:
+        @date_time_value.iso_year_and_week_one_start(wkst)
+      end
+
+      def iso_weeks_in_year(wkst) #:nodoc:
+        @date_time_value.iso_weeks_in_year(wkst) #:nodoc:
+      end
+
+      # Return the "Natural' property value for the receover, in this case the receiver itself."
+      def to_ri_cal_date_or_date_time_value(timezone_finder = nil) #:nodoc:
+        self.for_parent(timezone_finder)
+      end
+      
+      # Return a Date property for this DateTime
+      def to_ri_cal_date_value(timezone_finder=nil)
+        PropertyValue::Date.new(timezone_finder, :value => @date_time_value.ical_date_str)
+      end
+
+      # Return the Ruby DateTime representation of the receiver
+      def to_datetime #:nodoc:
+        @date_time_value.to_datetime
+      end
+
+      # Returns a ruby DateTime object representing the receiver.
+      def ruby_value
+        if has_valid_tzinfo_tzid? && RiCal::TimeWithZone && tz_info_source?
+          RiCal::TimeWithZone.new(utc.to_datetime, ::Time.__send__(:get_zone, @tzid))
+        else
+          ::DateTime.civil(year, month, day, hour, min, sec, rational_tz_offset).set_tzid(@tzid)
+        end
+      end
+
+      alias_method :to_ri_cal_ruby_value, :to_datetime
+      alias_method :to_finish_time, :ruby_value
+      
+      def to_zulu_time
+        utc.to_datetime
+      end
+      
+      # If a time is floating, then the utc of it's start time may actually be as early 
+      # as 12 hours earlier if the occurrence is being viewed in a time zone just west
+      # of the International Date Line
+      def to_zulu_occurrence_range_start_time
+        if floating?
+          @date_time_value.advance(:hours => -12, :offset => 0).to_datetime
+        else
+          to_zulu_time
+        end
+      end
+      
+      
+      # If a time is floating, then the utc of it's start time may actually be as early 
+      # as 12 hours later if the occurrence is being viewed in a time zone just east
+      # of the International Date Line
+      def to_zulu_occurrence_range_finish_time
+        if floating?
+          utc.advance(:hours => 12).to_datetime
+        else
+          to_zulu_time
+        end
+      end
+      
+      def add_date_times_to(required_timezones) #:nodoc:
+        required_timezones.add_datetime(self, tzid) if has_local_timezone?
+      end
+      
+      def start_of_day?
+        [hour, min, sec] == [0,0,0]
+      end
+      
+      def for_occurrence(occurrence)
+        occurrence.to_ri_cal_date_time_value(timezone_finder)
+      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