ri_cal 0.5.0

data/lib/ri_cal/property_value.rb

@@ -0,0 +1,149 @@
+module RiCal
+  #- ©2009 Rick DeNatale, All rights reserved. Refer to the file README.txt for the license
+  #
+  # PropertyValue provides common implementation of various RFC 2445 property value types
+  class PropertyValue
+
+    attr_writer :params, :value #:nodoc:
+    attr_reader :timezone_finder #:nodoc:
+    def initialize(timezone_finder, options={}) # :nodoc:
+      @timezone_finder = timezone_finder
+      validate_value(options)
+      ({:params => {}}).merge(options).each do |attribute, val|
+        unless attribute == :name
+          setter = :"#{attribute.to_s.downcase}="
+          send(setter, val)
+        end
+      end
+    end
+    
+    def self.if_valid_string(timezone_finder, string) #:nodoc:
+      if valid_string?(string)
+        new(timezone_finder, :value => string)
+      else
+        nil
+      end
+    end
+
+    def validate_value(options) #:nodoc:
+      val = options[:value]
+      raise "Invalid property value #{val.inspect}" if val.kind_of?(String) && /^;/.match(val)
+    end
+
+    # return a hash containing the parameters and values, if any
+    def params
+      @params ||= {}
+    end
+
+    def to_options_hash #:nodoc:
+      options_hash = {:value => value}
+      options_hash[:params] = params unless params.empty?
+    end
+
+    def self.date_or_date_time(timezone_finder, separated_line) # :nodoc:
+      match = separated_line[:value].match(/(\d\d\d\d)(\d\d)(\d\d)((T?)((\d\d)(\d\d)(\d\d))(Z?))?/)
+      raise Exception.new("Invalid date") unless match
+      if match[5] == "T" # date-time
+        time = Time.utc(match[1].to_i, match[2].to_i, match[3].to_i, match[7].to_i, match[8].to_i, match[9].to_i)
+        parms = (separated_line[:params] ||{}).dup
+        if match[10] == "Z"
+          raise Exception.new("Invalid time, cannot combine Zulu with timezone reference") if parms[:tzid]
+          parms['TZID'] = "UTC"
+        end
+        PropertyValue::DateTime.new(timezone_finder, separated_line.merge(:params => parms))
+      else
+        PropertyValue::Date.new(timezone_finder, separated_line)
+      end
+    end
+    
+    def self.date_or_date_time_or_period(timezone_finder, separated_line) #:nodoc:
+      if separated_line[:value].include?("/")
+        PropertyValue::Period.new(timezone_finder, separated_line)
+      else
+        date_or_date_time(timezone_finder, separated_line)
+      end
+    end
+
+    # def self.from_string(string) # :nodoc:
+    #   new(nil, :value => string)
+    # end
+
+    def self.convert(timezone_finder, value) #:nodoc:
+      new(timezone_finder, :value => value)
+    end
+
+    # Determine if another object is equivalent to the receiver.
+    def ==(o)
+      if o.class == self.class
+        equality_value == o.equality_value
+      else
+        super
+      end
+    end
+
+    # Return the string value
+    def value
+      @value
+    end
+
+    def equality_value #:nodoc:
+      value
+    end
+
+    def visible_params # :nodoc:
+      params
+    end
+
+    def parms_string #:nodoc:
+      if (vp = visible_params) && !vp.empty?
+        # We only sort for testability reasons
+        vp.keys.sort.map {|key| ";#{key}=#{vp[key]}"}.join
+      else
+        ""
+      end
+    end
+
+    # Return a string representing the receiver in RFC 2445 format
+    def to_s #:nodoc:
+      "#{parms_string}:#{value}"
+    end
+
+    # return the ruby value
+    def ruby_value
+      self.value
+    end
+
+    def to_ri_cal_property_value #:nodoc:
+      self
+    end
+    
+    def find_timezone(timezone_identifier) #:nodoc:
+      if timezone_finder
+        timezone_finder.find_timezone(timezone_identifier)
+      else
+        raise "Unable to find timezone with tzid #{timezone_identifier}"
+      end
+    end
+    
+    def default_tzid #:nodoc:
+      if timezone_finder
+        timezone_finder.default_tzid
+      else
+        PropertyValue::DateTime.default_tzid
+      end
+    end
+    
+    def tz_info_source? #:nodoc:
+      if timezone_finder
+        timezone_finder.tz_info_source?
+      else
+        true
+      end
+    end
+  end
+end
+
+Dir[File.dirname(__FILE__) + "/property_value/*.rb"].sort.each do |path|
+  filename = File.basename(path)
+  require path
+end

data/lib/ri_cal/property_value/array.rb

@@ -0,0 +1,27 @@
+module RiCal
+  class PropertyValue
+    #- ©2009 Rick DeNatale, All rights reserved. Refer to the file README.txt for the license
+    #
+    class Array < PropertyValue # :nodoc:
+
+      def value=(val)
+        case val
+        when String
+          @value = val.split(",")
+        else
+          @value = val
+        end
+      end
+      
+      def value
+        @value.join(",")
+      end
+      
+      def self.convert(timezone_finder, ruby_object) # :nodoc:
+        self.new(timezone_finder, :value => ruby_object)
+      end
+      
+    end
+  end
+
+end

data/lib/ri_cal/property_value/cal_address.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 CalAddress property value
+    # which is defined in 
+    # RFC 2445 section 4.3.3 p 34
+    class CalAddress < PropertyValue
+    end
+  end
+end

data/lib/ri_cal/property_value/date.rb

@@ -0,0 +1,175 @@
+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 Date property value
+    # which is defined in
+    # RFC 2445 section 4.3.4 p 34
+    class Date < PropertyValue
+
+      def self.valid_string?(string) #:nodoc:
+        string =~ /^\d{8}$/
+      end
+
+      # Returns the value of the reciever as an RFC 2445 iCalendar string
+      def value
+        if @date_time_value
+          @date_time_value.strftime("%Y%m%d")
+        else
+          nil
+        end
+      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)
+        case val
+        when nil
+          @date_time_value = nil
+        when String
+          @date_time_value = ::DateTime.parse(::DateTime.parse(val).strftime("%Y%m%d"))
+        when ::Time, ::Date, ::DateTime
+          @date_time_value = ::DateTime.parse(val.strftime("%Y%m%d"))
+        end
+      end
+
+      # Nop to allow occurrence list to try to set it
+      def tzid=(val)#:nodoc:
+      end
+
+      def tzid #:nodoc:
+        nil
+      end
+
+      def visible_params #:nodoc:
+        {"VALUE" => "DATE"}.merge(params)
+      end
+
+      # Returns the year (including the century)
+      def year
+        @date_time_value.year
+      end
+
+      # Returns the month of the year (1..12)
+      def month
+        @date_time_value.month
+      end
+
+      # Returns the day of the month
+      def day
+        @date_time_value.day
+      end
+
+      # Returns the ruby representation a ::Date
+      def ruby_value
+        ::Date.parse(@date_time_value.strftime("%Y%m%d"))
+      end
+
+      alias_method :to_ri_cal_ruby_value, :ruby_value
+
+      # Return an instance of RiCal::PropertyValue::DateTime representing the start of this date
+      def to_ri_cal_date_time_value
+        PropertyValue::DateTime.new(timezone_finder, :value => @date_time_value)
+      end
+
+      # Return this date property
+      def to_ri_cal_date_value(timezone_finder = nil)
+        self
+      end
+
+      # Return the "Natural' property value for the date_property, in this case the date property itself."
+      def to_ri_cal_date_or_date_time_value
+        self
+      end
+
+      def compute_change(d, options) #:nodoc:
+        ::Date.civil((options[:year] || d.year), (options[:month] || d.month), (options[:day] || d.day))
+      end
+
+      def compute_advance(d, options) #:nodoc:
+        d = d >> options[:years] * 12 if options[:years]
+        d = d >> options[:months]     if options[:months]
+        d = d +  options[:weeks] * 7  if options[:weeks]
+        d = d +  options[:days]       if options[:days]
+        compute_change(@date_time_value, :year => d.year, :month => d.month, :day => d.day)
+      end
+
+      def advance(options) #:nodoc:
+        PropertyValue::Date.new(timezone_finder, :value => compute_advance(@date_time_value, options), :params =>(params ? params.dup : nil) )
+      end
+
+      def change(options) #:nodoc:
+        PropertyValue::Date.new(timezone_finder,:value => compute_change(@date_time_value, options), :params => (params ? params.dup : nil) )
+      end
+
+      def add_date_times_to(required_timezones) #:nodoc:
+        # Do nothing since dates don't have a timezone
+      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(to_ri_cal_date_time_value)
+      end
+
+      def subtract_from_date_time_value(date_time)
+        to_ri_cal_date_time_value.subtract_from_date_time_value(date_time)
+      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(to_ri_cal_date_time_value)
+      end
+
+      # Delegate unknown messages to the wrappered Date instance.
+      # TODO: Is this really necessary?
+      def method_missing(selector, *args) #:nodoc:
+        @date_time_value.send(selector, *args)
+      end
+
+      # TODO: consider if this should be a period rather than a hash
+      def occurrence_period(default_duration) #:nodoc:
+        date_time = self.to_ri_cal_date_time_value
+        RiCal::OccurrencePeriod.new(date_time, date_time.advance(:hours => 24, :seconds => -1))
+      end
+      
+      def start_of_day?
+        true
+      end
+      
+      def to_zulu_occurrence_range_start_time
+        to_ri_cal_date_time_value.to_zulu_occurrence_range_start_time
+      end
+      
+      def to_zulu_occurrence_range_finish_time
+        to_ri_cal_date_time_value.end_of_day.to_zulu_occurrence_range_finish_time
+      end
+      
+      def to_finish_time
+        to_ri_cal_date_time_value.end_of_day.to_datetime
+      end
+      
+      def for_occurrence(occurrence)
+        if occurrence.start_of_day?
+          occurrence.to_ri_cal_date_value(timezone_finder)
+        else
+          occurrence.for_parent(timezone_finder)
+        end
+      end
+    end
+  end
+end

data/lib/ri_cal/property_value/date_time.rb

@@ -0,0 +1,335 @@
+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.strftime("%Y%m%dT%H%M%S#{tzid == "UTC" ? "Z" : ""}")
+        else
+          nil
+        end
+      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 = ::DateTime.parse(val)
+          if val =~/Z/
+            self.tzid = 'UTC'
+          else
+            @tzid ||= :floating
+          end
+        when ::DateTime
+          @date_time_value = val
+        when ::Date, ::Time
+          @date_time_value = ::DateTime.parse(val.to_s)
+        end
+      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)
+       @date_time_value <=> other.to_datetime
+      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 nth_wday_in_month(n, which_wday) #:nodoc:
+        @date_time_value.nth_wday_in_month(n, which_wday, self)
+      end
+
+      def nth_wday_in_year(n, which_wday) #:nodoc:
+        @date_time_value.nth_wday_in_year(n, which_wday, self)
+      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.strftime("%Y%m%d"))
+      end
+
+      # Return the Ruby DateTime representation of the receiver
+      def to_datetime #:nodoc:
+        @date_time_value
+      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, :to_datetime
+      
+      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?
+          utc.advance(:hours => -12).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