rubyredrick-ri_cal 0.0.2

data/lib/ri_cal/property_value/array.rb

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

data/lib/ri_cal/property_value/cal_address.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 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,119 @@
+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
+      # 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
+
+      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(:value => @date_time_value)
+      end
+
+      # Return this date property
+      def to_ri_cal_date_value
+        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
+
+
+      # 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_hash(default_duration) #:nodoc:
+        date_time = self.to_ri_cal_date_time_value
+        {:start => date_time,
+          :end => date_time.advance(:hours => 24, :seconds => -1)}
+        end
+      end
+    end
+  end

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

@@ -0,0 +1,43 @@
+module RiCal
+  class PropertyValue
+    #- ©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

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

@@ -0,0 +1,180 @@
+module RiCal
+  class PropertyValue
+    #- ©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 compute_change(d, options) # :nodoc:
+        ::DateTime.civil(
+        options[:year]  || d.year,
+        options[:month] || d.month,
+        options[:day]   || d.day,
+        options[:hour]  || d.hour,
+        options[:min]   || (options[:hour] ? 0 : d.min),
+        options[:sec]   || ((options[:hour] || options[:min]) ? 0 : d.sec),
+        options[:offset]  || d.offset,
+        options[:start]  || d.start
+        )
+      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]
+        datetime_advanced_by_date = compute_change(@date_time_value, :year => d.year, :month => d.month, :day => d.day)
+        seconds_to_advance = (options[:seconds] || 0) + (options[:minutes] || 0) * 60 + (options[:hours] || 0) * 3600
+        seconds_to_advance == 0 ? datetime_advanced_by_date : datetime_advanced_by_date + Rational(seconds_to_advance.round, 86400)
+      end
+
+      def advance(options) # :nodoc:
+        PropertyValue::DateTime.new(timezone_finder,
+                                    :value => compute_advance(@date_time_value, options),
+                                    :tzid => tzid,
+                                    :params =>(params ? params.dup : nil)
+        )
+      end
+
+      def change(options) # :nodoc:
+        PropertyValue::DateTime.new(timezone_finder,
+                                    :value => compute_change(@date_time_value, options),
+                                    :tzid => tzid,
+                                    :params => (params ? params.dup : nil)
+        )
+      end
+
+      def change_sec(new_sec) #:nodoc:
+        PropertyValue::DateTime.civil(self.year, self.month, self.day, self.hour, self.min, sec, self.offset, self.start, params)
+      end
+
+      def change_min(new_min) #:nodoc:
+        PropertyValue::DateTime.civil(self.year, self.month, self.day, self.hour, new_min, self.sec, self.offset, self.start, params)
+      end
+
+      def change_hour(new_hour) #:nodoc:
+        PropertyValue::DateTime.civil(self.year, self.month, self.day, new_hour, self.min, self.sec, self.offset, self.start, params)
+      end
+
+      def change_day(new_day) #:nodoc:
+        PropertyValue::DateTime.civil(self.year, self.month, new_day, self.hour, self.min, self.sec, self.offset, self.start, params)
+      end
+
+      def change_month(new_month) #:nodoc:
+        PropertyValue::DateTime.civil(self.year, new_month, self.day, self.hour, self.min, self.sec, self.offset, self.start, params)
+      end
+
+      def change_year(new_year) #:nodoc:
+        PropertyValue::DateTime.civil(new_year, self.month, self.day, self.hour, self.min, self.sec, self.offset, self.start, params)
+      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

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

@@ -0,0 +1,65 @@
+module RiCal
+  class PropertyValue
+    #- ©2009 Rick DeNatale
+    #- All rights reserved. Refer to the file README.txt for the license
+    #
+    # Time zone related ethods for DateTime
+    module TimezoneSupport      
+      # Return the timezone id of the receiver, or nil if it is a floating time
+      def tzid
+        @tzid
+      end
+
+      def tzid=(string) #:nodoc:
+        @tzid = string
+        @timezone = nil
+      end
+
+      def timezone #:nodoc:
+        @timezone ||= timezone_finder.find_timezone(@tzid)
+      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 != "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?
+          timezone.local_to_utc(self)
+        else  # Already local or a floating time
+          self
+        end
+      end
+      
+      # Predicate indicating whether or not the instance represents a ZULU time
+      def utc?
+        tzid == "UTC"
+      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