rubyredrick-ri_cal 0.5.3 → 0.6.0

data/History.txt

@@ -1,3 +1,14 @@
+=== 0.6.0 - 5 June 2009
+ Time for a minor version bump.
+ * Improved overall enumeration performance bypassing most of the effects of the poor performance of Ruby's DateTime class.
+ * Added a framework for performance monitoring during development.
+   - New performance directory with subdirs for code to be monitored for performance (subjects)
+   - New script files: 
+        script/benchmark_subject runs a ruby benchmark on one performance subject
+        script/profile_subject runs ruby-prof for a subject and puts a kcachegrind compatible calltree in the performance_data directory.
+   - New rake tasks: 
+        performance:benchmark runs benchmarks against all subjects in the performance directory and produces a consolidated output file in performance_data/benchmarks.out
+        performance:profile runs script/profile_subject against all subjects in the performance directory.
 === 0.5.3 - 1 June, 2009
  * Improved performance of time zone enumeration, TimeZonePeriod now caches occurrences
  * Added a profiling directory which contains ruby programs which benchmark and/or profile performance

data/Manifest.txt

@@ -46,6 +46,7 @@ lib/ri_cal/core_extensions/time/calculations.rb
 lib/ri_cal/core_extensions/time/conversions.rb
 lib/ri_cal/core_extensions/time/tzid_access.rb
 lib/ri_cal/core_extensions/time/week_day_predicates.rb
+lib/ri_cal/fast_date_time.rb
 lib/ri_cal/floating_timezone.rb
 lib/ri_cal/invalid_property_value.rb
 lib/ri_cal/invalid_timezone_identifer.rb
@@ -89,15 +90,18 @@ lib/ri_cal/property_value/text.rb
 lib/ri_cal/property_value/uri.rb
 lib/ri_cal/property_value/utc_offset.rb
 lib/ri_cal/required_timezones.rb
-profiling/ical_files/profile3.ics
-profiling/profile1.rb
-profiling/profile2.rb
-profiling/profile3.rb
+performance/paris_eastern/subject.rb
+performance/penultimate_weekday/subject.rb
+performance/psm_big_enum/ical.ics
+performance/psm_big_enum/subject.rb
+performance/utah_cycling/subject.rb
 ri_cal.gemspec
 sample_ical_files/from_ical_dot_app/test1.ics
+script/benchmark_subject
 script/console
 script/destroy
 script/generate
+script/profile_subject
 script/txt2html
 spec/ri_cal/component/alarm_spec.rb
 spec/ri_cal/component/calendar_spec.rb
@@ -111,6 +115,7 @@ spec/ri_cal/component_spec.rb
 spec/ri_cal/core_extensions/string/conversions_spec.rb
 spec/ri_cal/core_extensions/time/calculations_spec.rb
 spec/ri_cal/core_extensions/time/week_day_predicates_spec.rb
+spec/ri_cal/fast_date_time_spec.rb
 spec/ri_cal/occurrence_enumerator_spec.rb
 spec/ri_cal/parser_spec.rb
 spec/ri_cal/property_value/date_spec.rb

data/README.txt

@@ -348,12 +348,9 @@ or by a recent(>= 2.2) version of the ActiveSupport gem which is part of Ruby on
     
 === From github
 
-    #TODO: publish to github
-
 ==== As a Gem
 
-    #TODO: add the gem source info for github
-    sudo gem install ????? --source http://github.com/????
+    sudo gem install rubyredrick-ri_cal --source http://gems.github.com/
    
 ==== From source
 

data/lib/ri_cal/component/calendar.rb

@@ -140,7 +140,6 @@ module RiCal
 
 
         def rational_utc_offset(local)
-          # 86400 is the number of seconds in a day
           RiCal.RationalOffset[tzinfo.period_for_local(local, true).utc_total_offset]
         end
 

data/lib/ri_cal/core_extensions/string/conversions.rb

@@ -47,17 +47,7 @@ module RiCal
             raise "Invalid value for occurrence list #{self.inspect}"
           end
         end
- 
-        # code stolen from ActiveSupport Gem
-        unless  ::String.instance_methods.include?("camelize")
-          # Convert the receiver to camelized form
-          # This method duplicates the method provided by ActiveSupport, and will only be defined
-          # by the RiCal gem if it is not already defined.
-          def camelize
-            self.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
-          end
-        end
-      end
+       end
     end
   end
 end

data/lib/ri_cal/core_extensions/time/conversions.rb

@@ -27,23 +27,6 @@ module RiCal
         end
         
         unless defined? ActiveSupport
-          # Converts a Time object to a Date, dropping hour, minute, and second precision.
-          #
-          #   my_time = Time.now  # => Mon Nov 12 22:59:51 -0500 2007
-          #   my_time.to_date     # => Mon, 12 Nov 2007
-          #
-          #   your_time = Time.parse("1/13/2009 1:13:03 P.M.")  # => Tue Jan 13 13:13:03 -0500 2009
-          #   your_time.to_date                                 # => Tue, 13 Jan 2009
-          def to_date
-            ::Date.new(year, month, day)
-          end
-
-          # A method to keep Time, Date and DateTime instances interchangeable on conversions.
-          # In this case, it simply returns +self+.
-          def to_time
-            self
-          end
-
           # Converts a Time instance to a Ruby DateTime instance, preserving UTC offset.
           #
           #   my_time = Time.now    # => Mon Nov 12 23:04:21 -0500 2007

data/lib/ri_cal/core_extensions/time/week_day_predicates.rb

@@ -8,39 +8,6 @@ module RiCal
       # This module is included by Time, Date, and DateTime
       module WeekDayPredicates
         
-        # Determine the equivalent time on the day which falls on a particular weekday of the same year as the receiver
-        #
-        # == Parameters
-        # n:: the ordinal number being requested
-        # which_wday:: the weekday using Ruby time conventions, i.e. 0 => Sunday, 1 => Monday, ...
-        
-        # e.g. to obtain the 2nd Monday of the receivers year use
-        #
-        #   time.nth_wday_in_year(2, 1)
-        def nth_wday_in_year(n, which_wday, for_time = self)
-          if n > 0
-            first_of_year = for_time.to_ri_cal_property_value.change(:month => 1, :day => 1)
-            first_in_year = first_of_year.advance(:days => (which_wday - first_of_year.wday + 7) % 7)
-            first_in_year.advance(:days => (7*(n - 1)))
-          else
-            december25 = for_time.to_ri_cal_property_value.change(:month => 12, :day => 25)
-            last_in_year = december25.advance(:days => (which_wday - december25.wday + 7) % 7)
-            last_in_year.advance(:days => (7 * (n + 1)))
-          end
-        end
-        
-        # A predicate to determine whether or not the receiver falls on a particular weekday of its year.
-        # 
-        # See #nth_wday_in_year
-        #
-        # == Parameters
-        # n:: the ordinal number being requested
-        # which_wday:: the weekday using Ruby time conventions, i.e. 0 => Sunday, 1 => Monday, ...
-        def nth_wday_in_year?(n, which_wday)
-          target = nth_wday_in_year(n, which_wday)
-          [self.year, self.mon, self.day] == [target.year, target.mon, target.day]
-        end
-
         # Determine the day which falls on a particular weekday of the same month as the receiver
         #
         # == Parameters

data/lib/ri_cal/fast_date_time.rb

@@ -0,0 +1,214 @@
+module RiCal
+  #- ©2009 Rick DeNatale
+  #- All rights reserved. Refer to the file README.txt for the license
+  #
+  # FastDateTime mimics the Ruby Standard library DateTime class but avoids the use of Rational
+  # Instead of using a Rational for the utc offset, FastDateTime uses an integer seconds value
+  class FastDateTime
+    attr_accessor :date, :hour, :min, :sec, :offset, :secs_since_bod
+
+    SECONDS_IN_A_DAY = 60*60*24 unless defined? SECONDS_IN_A_DAY
+
+    include Comparable
+
+    def initialize(year, month, day, hour, min, sec, offset_seconds)
+      @date = Date.civil(year, month, day)
+      @secs_since_bod = hms_to_seconds(hour, min, sec)
+      @hour, @min, @sec, @offset = hour, min, sec, offset_seconds
+    end
+
+    def self.from_date_time(date_time)
+      new(date_time.year, date_time.month, date_time.day, date_time.hour, date_time.min, date_time.sec, (date_time.offset * SECONDS_IN_A_DAY).to_i)
+    end
+
+    alias_method :utc_offset_seconds, :offset
+
+    def ical_str
+      "%04d%02d%02dT%02d%02d%02d" % [year, month, day, hour, min, sec]
+    end
+
+    def ical_date_str
+      "%04d%02d%02d" % [year, month, day]
+    end
+
+    def year
+      @date.year
+    end
+
+    def month
+      @date.month
+    end
+
+    alias_method :mon, :month
+
+    def day
+      @date.day
+    end
+    
+    def wday
+      @date.wday
+    end
+
+    def to_datetime
+      DateTime.civil(year, month, day, hour, min, sec, RiCal.RationalOffset[utc_offset_seconds])
+    end
+
+    def ==(other)
+      [date, secs_since_bod, offset] == [other.date, other.secs_since_bod, other.offset]
+    end
+
+    def <=> (other)
+      if FastDateTime === other
+        [date, secs_since_bod] <=> [other.date, other.secs_since_bod]
+      else
+        [year, month, day, hour, min, sec] <=> [other.year, other.month, other.day, other.hour, other.min, other.sec]
+      end
+    end
+
+    def to_s
+      "#{year}/#{month}/#{day} #{hour}:#{min}:#{sec} #{offset}"
+    end
+
+    # def jd
+    #   date.jd
+    # end
+    # 
+    def days_in_month
+      date.days_in_month
+    end
+
+    alias_method :inspect, :to_s
+
+    # Return a new FastDateTime based on the receiver but with changes specified by the options
+    def change(options)
+      FastDateTime.new(
+      options[:year]  || year,
+      options[:month] || month,
+      options[:day]   || day,
+      options[:hour]  || hour,
+      options[:min]   || (options[:hour] ? 0 : min),
+      options[:sec]   || ((options[:hour] || options[:min]) ? 0 : sec),
+      options[:offset]  || offset
+      )
+    end
+
+    # def new_offset(ofst)
+    #   if ofst == offset
+    #     self
+    #   else
+    #     advance(:seconds => offset - ofset, :offset => ofst)
+    #   end
+    # end
+
+    def hms_to_seconds(hours, minutes, seconds)
+      seconds + 60 *(minutes + (60 * hours))
+    end
+
+    def seconds_to_hms(total_seconds)
+      sign = total_seconds <=> 0
+      remaining = total_seconds.abs
+      seconds = sign * (remaining % 60)
+      remaining = remaining / 60
+      minutes = sign * (remaining % 60)
+      [remaining / 60, minutes, seconds]
+    end
+
+    def adjust_day_delta(day_delta, new_secs_since_bod)
+      if new_secs_since_bod == 0
+        [day_delta, new_secs_since_bod]
+      elsif new_secs_since_bod > 0
+        [day_delta + (new_secs_since_bod / SECONDS_IN_A_DAY), new_secs_since_bod % SECONDS_IN_A_DAY]
+      else new_secs_since_bod
+        [day_delta - (1 + new_secs_since_bod.abs / SECONDS_IN_A_DAY), 
+         SECONDS_IN_A_DAY - (new_secs_since_bod.abs % SECONDS_IN_A_DAY)]
+      end
+     end
+
+
+    def advance(options) # :nodoc:
+      new_date = @date
+      new_offset = options[:offset] || offset
+      month_delta = (options[:years] || 0) * 12 + (options[:months] || 0)
+      day_delta =   (options[:weeks] || 0) * 7 + (options[:days] || 0)
+      sec_delta = hms_to_seconds((options[:hours] || 0), (options[:minutes] || 0), (options[:seconds] || 0))
+      day_delta, new_secs_since_bod = *adjust_day_delta(day_delta, secs_since_bod + sec_delta)
+      new_hour, new_min, new_sec = *seconds_to_hms(new_secs_since_bod)
+      new_date = new_date >> month_delta unless month_delta == 0
+      new_date += day_delta unless day_delta == 0
+      FastDateTime.new(new_date.year, new_date.month, new_date.day, new_hour, new_min, new_sec, new_offset)
+    end
+
+    # Determine the day which falls on a particular weekday of the same month as the receiver
+    #
+    # == Parameters
+    # n:: the ordinal number being requested
+    # which_wday:: the weekday using Ruby time conventions, i.e. 0 => Sunday, 1 => Monday, ...
+
+    # e.g. to obtain the 3nd Tuesday of the receivers month use
+    #
+    #   time.nth_wday_in_month(2, 2)
+    def nth_wday_in_month(n, which_wday)
+      first_of_month = change(:day => 1)
+      first_in_month = first_of_month.advance(:days => (which_wday - first_of_month.wday))
+      first_in_month = first_in_month.advance(:days => 7) if first_in_month.month != first_of_month.month
+      if n > 0
+        first_in_month.advance(:days => (7*(n - 1)))
+      else
+        possible = first_in_month.advance(:days => 21)
+        possible = possible.advance(:days => 7) while possible.month == first_in_month.month
+        last_in_month = possible.advance(:days => - 7)
+        (last_in_month.advance(:days => - (7*(n.abs - 1))))
+      end
+    end
+    
+    # Determine the equivalent time on the day which falls on a particular weekday of the same year as the receiver
+    #
+    # == Parameters
+    # n:: the ordinal number being requested
+    # which_wday:: the weekday using Ruby time conventions, i.e. 0 => Sunday, 1 => Monday, ...
+    
+    # e.g. to obtain the 2nd Monday of the receivers year use
+    #
+    #   time.nth_wday_in_year(2, 1)
+    def nth_wday_in_year(n, which_wday)
+      if n > 0
+        first_of_year = change(:month => 1, :day => 1)
+        first_in_year = first_of_year.advance(:days => (which_wday - first_of_year.wday + 7) % 7)
+        first_in_year.advance(:days => (7*(n - 1)))
+      else
+        december25 = change(:month => 12, :day => 25)
+        last_in_year = december25.advance(:days => (which_wday - december25.wday + 7) % 7)
+        last_in_year.advance(:days => (7 * (n + 1)))
+      end
+    end
+
+
+    # Return a DateTime which is the beginning of the first day on or before the receiver
+    # with the specified wday
+    def start_of_week_with_wkst(wkst)
+      wkst ||= 1
+      date = @date
+      date -= 1 while date.wday != wkst
+      date
+    end
+    
+    def iso_weeks_in_year(wkst)
+      @date.iso_weeks_in_year(wkst)
+    end
+    
+    def iso_year_start(wkst)
+      @date.iso_year_start(wkst)
+    end
+    
+    def iso_year_and_week_one_start(wkst)
+      @date.iso_year_and_week_one_start(wkst)
+    end
+    
+    def cmp_fast_date_time_value(other)
+      other <=> self
+    end
+
+    
+  end
+
+end

data/lib/ri_cal/occurrence_enumerator.rb

@@ -222,10 +222,10 @@ module RiCal
       @exdate_property = nil
       @recurrence_id_property = occurrence_start
       if @dtend_property && !occurrence_end
-        occurrence_end = occurrence_start + (@dtend_property - @dtstart_property)
+         occurrence_end = occurrence_start + (@dtend_property - @dtstart_property)
       end
-      @dtstart_property = dtstart_property.for_occurrence(occurrence_start)
-      @dtend_property = dtend_property.for_occurrence(occurrence_end) if @dtend_property
+      @dtstart_property = @dtstart_property.for_occurrence(occurrence_start)
+      @dtend_property = (@dtend_property || @dtstart_property).for_occurrence(occurrence_end) if occurrence_end
       self
     end
 

data/lib/ri_cal/property_value/date.rb

@@ -15,7 +15,7 @@ module RiCal
       # 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")
+          @date_time_value.ical_date_str
         else
           nil
         end
@@ -34,9 +34,11 @@ module RiCal
         when nil
           @date_time_value = nil
         when String
-          @date_time_value = ::DateTime.parse(::DateTime.parse(val).strftime("%Y%m%d"))
+          @date_time_value = FastDateTime.from_date_time(::DateTime.parse(::DateTime.parse(val).strftime("%Y%m%d")))
         when ::Time, ::Date, ::DateTime
-          @date_time_value = ::DateTime.parse(val.strftime("%Y%m%d"))
+          @date_time_value = FastDateTime.from_date_time(::DateTime.parse(val.strftime("%Y%m%d")))
+        when FastDateTime
+          @date_time_value = val
         end
       end
 
@@ -69,7 +71,7 @@ module RiCal
 
       # Returns the ruby representation a ::Date
       def ruby_value
-        ::Date.parse(@date_time_value.strftime("%Y%m%d"))
+        @date_time_value.date
       end
 
       alias_method :to_ri_cal_ruby_value, :ruby_value
@@ -89,24 +91,12 @@ module RiCal
         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) )
+        PropertyValue::Date.new(timezone_finder, :value => @date_time_value.advance(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) )
+        PropertyValue::Date.new(timezone_finder,:value => @date_time_value.change(options), :params => (params ? params.dup : nil) )
       end
 
       def add_date_times_to(required_timezones) #:nodoc:
@@ -146,26 +136,30 @@ module RiCal
         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_floating_date_time_property
+        PropertyValue::DateTime.new(timezone_finder, :value => @date_time_value.ical_str)
+      end
+
       def to_zulu_occurrence_range_start_time
-        to_ri_cal_date_time_value.to_zulu_occurrence_range_start_time
+        to_floating_date_time_property.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)
+           occurrence.to_ri_cal_date_value(timezone_finder)
         else
           occurrence.for_parent(timezone_finder)
         end

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

@@ -5,32 +5,10 @@ module RiCal
       #
       # 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:
-          months_advance = (options[:years] || 0) * 12 + (options[:months] || 0)
-          d = d >> months_advance unless months_advance == 0
-          days_advance = (options[:weeks] || 0) * 7 + (options[:days] || 0)
-          d = d +  days_advance unless days_advance == 0
-          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 + RiCal.RationalOffset[seconds_to_advance.round]
-        end
 
         def advance(options) # :nodoc:
           PropertyValue::DateTime.new(timezone_finder,
-          :value => compute_advance(@date_time_value, options),
+          :value => @date_time_value.advance(options),
           :tzid => @tzid,
           :params =>(params ? params.dup : nil)
           )
@@ -38,34 +16,34 @@ module RiCal
 
         def change(options) # :nodoc:
           PropertyValue::DateTime.new(timezone_finder,
-          :value => compute_change(@date_time_value, options),
+          :value => @date_time_value.change(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)
+          change(:sec => new_sec)
         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)
+          change(:min => new_min)
         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)
+          change(:hour => new_hour)
         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)
+          change(:day => new_day)
         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)
+          change(:month => new_month)
         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)
+          change(:year => new_year)
         end
 
         # Return a DATE-TIME property representing the receiver on a different day (if necessary) so that

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

@@ -58,7 +58,7 @@ module RiCal
 
         def rational_tz_offset #:nodoc:
           if has_local_timezone?
-            @rational_tz_offset ||= timezone.rational_utc_offset(@date_time_value)
+            @rational_tz_offset ||= timezone.rational_utc_offset(@date_time_value.to_datetime)
           else
             @rational_tz_offset ||= RiCal.RationalOffset[0]
           end

data/lib/ri_cal/property_value/date_time.rb

@@ -66,7 +66,7 @@ module RiCal
       # 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" : ""}")
+          "#{@date_time_value.ical_str}#{tzid == "UTC" ? "Z" : ""}"
         else
           nil
         end
@@ -85,16 +85,18 @@ module RiCal
         when nil
           @date_time_value = nil
         when String
-          @date_time_value = ::DateTime.parse(val)
+          @date_time_value = FastDateTime.from_date_time(::DateTime.parse(val))
           if val =~/Z/
             self.tzid = 'UTC'
           else
             @tzid ||= :floating
           end
-        when ::DateTime
+        when FastDateTime
           @date_time_value = val
+        when ::DateTime
+          @date_time_value = FastDateTime.from_date_time(val)
         when ::Date, ::Time
-          @date_time_value = ::DateTime.parse(val.to_s)
+          @date_time_value = FastDateTime.from_date_time(::DateTime.parse(val.to_s))
         end
         reset_cached_values
       end
@@ -173,7 +175,11 @@ module RiCal
       # 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
+       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
@@ -181,12 +187,21 @@ module RiCal
         [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:
-        @date_time_value.nth_wday_in_month(n, which_wday, self)
+        with_date_time_value(@date_time_value.nth_wday_in_month(n, which_wday))
       end
 
       def nth_wday_in_year(n, which_wday) #:nodoc:
-        @date_time_value.nth_wday_in_year(n, which_wday, self)
+        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:
@@ -273,12 +288,12 @@ module RiCal
       
       # 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"))
+        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
+        @date_time_value.to_datetime
       end
 
       # Returns a ruby DateTime object representing the receiver.
@@ -302,7 +317,7 @@ module RiCal
       # of the International Date Line
       def to_zulu_occurrence_range_start_time
         if floating?
-          utc.advance(:hours => -12).to_datetime
+          @date_time_value.advance(:hours => -12, :offset => 0).to_datetime
         else
           to_zulu_time
         end

data/lib/ri_cal.rb

@@ -14,7 +14,7 @@ module RiCal
   autoload :OccurrenceEnumerator, "#{my_dir}/ri_cal/occurrence_enumerator.rb"
   
   # :stopdoc:
-  VERSION = '0.5.3'
+  VERSION = '0.6.0'
   LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
   PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR