rubyredrick-ri_cal 0.0.2

data/lib/ri_cal/property_value/date_time.rb

@@ -0,0 +1,324 @@
+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 initialize(timezone_finder, options={}) #:nodoc:
+      #   super(timezone_finder ? timezone_finder : Calendar.new, options)
+      # end
+      #
+      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.default_tzid # :nodoc:
+        @default_tzid ||= "UTC"
+      end
+
+      def self.params_for_tzid(tzid) #:nodoc:
+        if tzid == FloatingTimezone
+          {}
+        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 'none' 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 = value
+      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
+          self.tzid = 'UTC' if val =~/Z/
+          @date_time_value = ::DateTime.parse(val)
+        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 an array it is expected to have a time or datetime as its first element, and a time zone
+      # identifier string as the second element
+      #
+      # Otherwise determine if the object acts like an activesupport enhanced time, and extract its timezone
+      # idenfifier if it has one.
+      #
+      def self.time_and_tzid(object)
+        if ::Array === object
+          object, identifier = object[0], object[1]
+        else
+          activesupport_time = object.acts_like_time? rescue nil
+          time_zone = activesupport_time && object.time_zone rescue nil
+          identifier = time_zone && (time_zone.respond_to?(:tzinfo) ? time_zone.tzinfo  : time_zone).identifier
+        end
+        [object, identifier]
+      end
+
+      # A hack to detect whether an array passed to convert is a
+      def self.single_time_or_date?(ruby_object)
+        if (::Array === ruby_object) 
+          if (ruby_object.length == 2) && (::String === ruby_object[1])
+            case ruby_object[0]
+            when ::Date, ::DateTime, ::Time, PropertyValue::Date, PropertyValue::DateTime
+              ruby_object
+            else
+              nil
+            end
+          end
+        else
+          ruby_object
+        end
+      end
+
+
+      def self.convert(timezone_finder, ruby_object) # :nodoc:
+        convert_with_tzid_or_nil(timezone_finder, ruby_object) || ruby_object.to_ri_cal_date_or_date_time_value.for_parent(timezone_finder)
+      end
+
+      # Create an instance of RiCal::PropertyValue::DateTime representing a Ruby Time or DateTime
+      # If the ruby object has been extended by ActiveSupport to have a time_zone method, then
+      # the timezone will be used as the TZID parameter.
+      #
+      # Otherwise the class level default tzid will be used.
+      # == See
+      # * RiCal::PropertyValue::DateTime.default_tzid
+      # * RiCal::PropertyValue::DateTime#object_time_zone
+      def self.from_time(time_or_date_time)
+        convert_with_tzid_or_nil(nil, time_or_date_time) ||
+        new(nil, :value => time_or_date_time.strftime("%Y%m%dT%H%M%S"), :params => default_tzid_hash)
+      end
+
+      def self.convert_with_tzid_or_nil(timezone_finder, ruby_object) # :nodoc:
+        time, identifier = *self.time_and_tzid(ruby_object)
+        if identifier
+          new(
+          timezone_finder,
+          :params => params_for_tzid(identifier),
+          :value => time.strftime("%Y%m%d%H%M%S")
+          )
+        else
+          nil
+        end
+      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']
+          @tzid = params_timezone
+        end
+      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)
+        @date_time_value.nth_wday_in_month(n, which_wday, self)
+      end
+
+      def nth_wday_in_year(n, which_wday)
+        @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
+
+      def in_same_month_as?(other)
+        [other.year, other.month] == [year, 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_hash(default_duration) # :nodoc:
+        {:start => self, :end => (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
+        self
+      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)
+        @date_time_value.iso_weeks_in_year(wkst)
+      end
+
+      # Return the "Natural' property value for the receover, in this case the receiver itself."
+      def to_ri_cal_date_or_date_time_value
+        self
+      end
+
+      # Return the Ruby DateTime representation of the receiver
+      def to_datetime
+        @date_time_value
+      end
+
+      # Returns a ruby DateTime object representing the receiver.
+       def ruby_value
+        to_datetime
+      end
+
+      alias_method :to_ri_cal_ruby_value, :ruby_value
+
+      def add_date_times_to(required_timezones) #:nodoc:
+        required_timezones.add_datetime(self, tzid) if has_local_timezone?
+      end
+    end
+  end
+end

data/lib/ri_cal/property_value/duration.rb

@@ -0,0 +1,106 @@
+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(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)
+          new(parent, :value => "#{sign}P#{day_part}T#{day_part}#{hour_part}#{min_part}#{sec_part}")        
+        end
+      end
+
+      def self.convert(parent, ruby_object) # :nodoc:
+        ruby_object.to_ri_cal_duration_value.for_parent(parent)
+      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 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,12 @@
+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,13 @@
+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,82 @@
+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
+      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 next_occurrence
+          if @index < occurrence_list.length
+            result = occurrence_list[@index].occurrence_hash(default_duration)
+            @index += 1
+            result
+          else
+            nil
+          end
+        end
+      end
+      
+      
+      def self.convert(timezone_finder, ruby_object) # :nodoc:
+        if PropertyValue::DateTime.single_time_or_date?(ruby_object)
+          values = [ruby_object]
+        else
+          values = ruby_object
+        end
+        super(timezone_finder, values)
+      end
+
+      def value=(val) #:nodoc:
+        super
+        case params[:value]
+        when 'DATE-TIME', nil
+          @elements = @value.map {|val| PropertyValue::DateTime.convert(self, val)}.sort
+          @value = @elements.map {|element| element.value}
+        when 'DATE'
+          @elements = @value.map {|val| PropertyValue::Date.new(self, val)}.sort
+          @value = @elements.map {|element| element.value}
+        when 'PERIOD'
+        end
+      end
+    end
+    
+    attr_writer :elements
+    private :elements=
+    
+    def for_parent(parent)
+      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)
+      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,63 @@
+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 for_parent(parent)
+        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
+
+      # TODO: consider if this should be a period rather than a hash
+      def occurrence_hash(default_duration) #:nodoc:
+        {:start => self, :end => (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,98 @@
+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