icalendar-rrule 0.1.7 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffa993b8697f4800c40fa49adeafa04b32bb312f06107db10d1ce2031e4d90da
-  data.tar.gz: 543226f1ad33e913446693a985ca88ccb0a3996481dc93e7b8f87522e3d5af26
+  metadata.gz: b891ac836e382f65aa522d6fc6b049483b3296deef1fe9d2bb196ed6bb2de9bc
+  data.tar.gz: 5f99a1568a014411c01559505dd71068e630fca5cdbeb3e32fbb246fecd24190
 SHA512:
-  metadata.gz: 0e10b375f6fa9a8defe57c38294923a7edcb3ae3dd0d6ab0c433ff3f9e51f44af4cf0df84f0bcfae917856fbc5775138c66980d19b901c6bcd557ca3eb686b2c
-  data.tar.gz: cc0bc366ef7839f451d3885ec9fa1bdaabb66c0f7c20cc4de651088dd7627fb5c8dd07606c6e88bd54d4083d237a206258f38189b1261f1672e8b1a87a2ed51a
+  metadata.gz: ab80482e0f12d0cc47b11e28bbcf7f887bf42e50ed9e6d74dea0f24202b42215c62585347e94e72e8cb5dd38e04bf0e507745520092c7a11af36bc48182ffea1
+  data.tar.gz: 6a62fab4d640445562924807ebd7ed8eeadba97d1a5630f2c8bcf399977e6d1ece789efe17dbf21c50e05ee04b289bf81220e81075a3a698ef79531dcba5dbe2

data/CHANGELOG.md

@@ -0,0 +1,33 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.2.0] - 2025-12-24
+
+### Added
+- Support for tasks (VTODOs) with RRULE expansion
+- New `single_timestamp?` predicate for zero-duration events/deadline-only tasks
+- Comprehensive timezone extraction with multiple fallback strategies
+- Better system timezone detection (ENV['TZ'], /etc/timezone, TZInfo)
+
+### Changed
+- **BREAKING**: Events without explicit timezone now use system timezone instead of UTC
+- All-day events without DTEND now correctly compute 1-day duration in date-space
+- Relaxed `ice_cube` dependency to >= 0.16 (tested with 0.17.0)
+- `all_day?` now returns false for tasks (only applies to events)
+
+### Fixed
+- Timezone handling for recurring events (RRULE expansion now preserves timezone)
+- Floating time interpretation (DateTime with offset 0 no longer treated as UTC)
+- All-day events no longer experience timezone shift errors
+- Compatibility with icalendar gem 2.12.1 (DowncasedHash handling)
+- Task time handling (zero-duration tasks with only DUE)
+
+### Internal
+- Enhanced `_extract_explicit_timezone` for better timezone detection
+- Added `_dtstart_is_all_day?` helper
+- Improved `_guess_system_timezone` with 5 fallback methods
+- Better test coverage (145+ tests, including exotic timezones)
+
+## [0.1.7] - 2020-xx-xx
+- Previous stable release

data/lib/icalendar/rrule/version.rb

@@ -2,6 +2,6 @@
 
 module Icalendar
   module Rrule
-    VERSION = '0.1.7'
+    VERSION = '0.2.0'
   end
 end

data/lib/icalendar/scannable-calendar.rb

@@ -52,8 +52,23 @@ module Icalendar
         result = []
         components.each do |comp|
           occurrences = comp.schedule.occurrences_between(begin_time, closing_time)
+
+          # Get the target timezone from the component
+          target_tz = comp.start_time.time_zone
+
           occurrences.each do |oc|
-            new_oc = Icalendar::Rrule::Occurrence.new(self, comp, oc.start_time, oc.end_time)
+            # Interpret the time components AS IF they're already in target timezone
+            # (don't convert, just reconstruct in the right zone)
+            start_tz = target_tz.local(
+              oc.start_time.year, oc.start_time.month, oc.start_time.day,
+              oc.start_time.hour, oc.start_time.min, oc.start_time.sec
+            )
+            end_tz = target_tz.local(
+              oc.end_time.year, oc.end_time.month, oc.end_time.day,
+              oc.end_time.hour, oc.end_time.min, oc.end_time.sec
+            )
+
+            new_oc = Icalendar::Rrule::Occurrence.new(self, comp, start_tz, end_tz)
             result << new_oc
           end
         end

data/lib/icalendar/schedulable-component.rb

@@ -93,8 +93,15 @@ module Icalendar
       end
 
       ##
-      # @return [Integer] the number of seconds this task will last.
-      #                   If no duration for this task is specified, this function returns zero.
+      # Returns the explicit duration from DURATION property or guessed duration.
+      #
+      # WARNING: This does NOT compute the actual duration between start_time and end_time!
+      # For events with DTEND but no DURATION property, this returns 0 or the guessed duration,
+      # even though the actual duration may be longer.
+      #
+      # To get the actual duration, use: (end_time.to_i - start_time.to_i)
+      #
+      # @return [Integer] explicit duration in seconds, or 0 if not specified
       # @api private
       def _duration_seconds # rubocop:disable Metrics/AbcSize
         return _guessed_duration unless _duration
@@ -103,6 +110,25 @@ module Icalendar
         d.seconds + (d.minutes * SEC_MIN) + (d.hours * SEC_HOUR) + (d.days * SEC_DAY) + (d.weeks * SEC_WEEK)
       end
 
+      # Check if dtstart looks like an all-day event (starts at midnight)
+      # This is used internally to determine if we should apply the 1-day duration rule
+      # @return [Boolean] true if dtstart is a Date or starts at midnight
+      # @api private
+      def _dtstart_is_all_day?
+        # Only apply the 1-day rule to Events, not Tasks
+        return false unless self.is_a?(Icalendar::Event)
+
+        return true if _dtstart.is_a?(Icalendar::Values::Date)
+
+        # If it's a DateTime, check if it's at midnight (00:00:00)
+        if _dtstart.respond_to?(:to_time) || _dtstart.respond_to?(:to_datetime)
+          time = _to_time_with_zone(_dtstart)
+          return time == time.beginning_of_day
+        end
+
+        false
+      end
+
       ##
       # Make an educated guess how long this event might last according to the following definition from RFC 5545:
       #
@@ -114,7 +140,7 @@ module Icalendar
       # @return [Integer] the number of seconds this task might last.
       # @api private
       def _guessed_duration
-        if _dtstart.is_a?(Icalendar::Values::Date) && _dtend.nil? && _duration.nil? && _due.nil?
+        if _dtstart_is_all_day? && _dtend.nil? && _duration.nil? && _due.nil?
           SEC_DAY
         else
           0
@@ -127,8 +153,11 @@ module Icalendar
       def start_time
         if _dtstart
           _to_time_with_zone(_dtstart)
-        elsif _due
+        elsif _due && _duration_seconds > 0
           _to_time_with_zone(_due.to_i - _duration_seconds)
+        elsif _due
+          # Task with only DUE, no duration: start == end (zero-duration/deadline-only)
+          _to_time_with_zone(_due)
         else
           _to_time_with_zone(NULL_TIME)
         end
@@ -143,17 +172,50 @@ module Icalendar
         elsif _dtend
           _to_time_with_zone(_dtend)
         elsif _dtstart
-          _to_time_with_zone(_dtstart.to_i + _duration_seconds)
+          # Special handling for all-day events without explicit end
+          if _dtstart_is_all_day? && _dtend.nil?
+            # Stay in date space: add days to the date, not seconds to timestamp
+            start_date = _dtstart_all_day_event_as_date
+            end_date = start_date + (_duration_seconds / SEC_DAY).days
+            _date_to_time_with_zone(end_date, component_timezone)
+          else
+            _to_time_with_zone(start_time.to_i + _duration_seconds)
+          end
         else
           _to_time_with_zone(NULL_TIME + _duration_seconds)
         end
       end
 
+      # Extract the date component from dtstart, assuming it's an all-day event
+      # @return [Date]
+      # @api private
+      def _dtstart_all_day_event_as_date
+        raise ArgumentError, "dtstart is not an all-day event" unless _dtstart_is_all_day?
+
+        if _dtstart.is_a?(Icalendar::Values::Date)
+          _dtstart.to_date
+        elsif _dtstart.respond_to?(:to_date)
+          _dtstart.to_date
+        else
+          # Fallback: convert via TimeWithZone
+          time_with_zone = _to_time_with_zone(_dtstart)
+          raise ArgumentError, "Cannot convert dtstart to date" unless time_with_zone.respond_to?(:to_date)
+          time_with_zone.to_date
+        end
+      end
+
       ##
       # Heuristic to determine whether the event is scheduled
-      # for a date without precising the exact time of day.
-      # @return [Boolean] true if the component is scheduled for a date, false otherwise.
+      # for a date without specifying the exact time of day.
+      #
+      # Note: This method always returns false for tasks (VTODOs),
+      # as the all-day concept only applies to events (VEVENTs).
+      #
+      # @return [Boolean] true if the component is an Event scheduled for an entire day,
+      #                   false for tasks or timed events
       def all_day?
+        return false unless self.is_a?(Icalendar::Event)
+
         _dtstart.is_a?(Icalendar::Values::Date) ||
           (start_time == start_time.beginning_of_day && end_time == end_time.beginning_of_day)
       end
@@ -164,6 +226,19 @@ module Icalendar
         start_time.next_day.beginning_of_day < end_time
       end
 
+      ##
+      # Indicates whether this component represents a single point in time
+      # rather than a time range. Common for:
+      # - Open-ended events (e.g., concert start time without known end)
+      # - Tasks with only a deadline (no start time specified)
+      #
+      # @return [Boolean] true if the component has no duration
+      def single_timestamp?
+        return false if start_time.nil? || end_time.nil?
+        # Compare at second precision (ignore potential microsecond differences)
+        start_time.to_i == end_time.to_i
+      end
+
       ##
       # Make sure, that we can always query for a _rrule_ array.
       # @return [array] an array of _ical repeat-rules_ (or an empty array
@@ -264,9 +339,13 @@ module Icalendar
       # Creates a schedule for this event
       # @return [IceCube::Schedule]
       def schedule # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-        schedule = IceCube::Schedule.new
-        schedule.start_time = start_time
-        schedule.end_time = end_time
+        # Calculate duration in seconds
+        duration_seconds = (end_time.to_i - start_time.to_i)  # Integer seconds
+
+        # Create a schedule with start_time and duration
+        # Convert to Ruby Time for IceCube compatibility
+        schedule = IceCube::Schedule.new(start_time.to_time, duration: duration_seconds)
+
         _rrules.each do |rrule|
           ice_cube_recurrence_rule = IceCube::Rule.from_ical(rrule)
           schedule.add_recurrence_rule(ice_cube_recurrence_rule)
@@ -299,6 +378,9 @@ module Icalendar
       #
       # rubocop:disable Metrics/MethodLength,Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
       def _to_time_with_zone(date_time, timezone = nil)
+        # Try to extract timezone from the date_time parameter first
+        timezone ||= _extract_explicit_timezone(date_time)
+        # Fall back to component timezone if no timezone could be extracted
         timezone ||= component_timezone
 
         # For Icalendar::Values::DateTime, we can extract the ical value. Which probably is already what we want.
@@ -317,6 +399,19 @@ module Icalendar
           return date_time_value.in_time_zone(timezone)
 
         elsif date_time_value.is_a?(DateTime)
+          # If DateTime has offset 0, treat it as "floating time" in the target timezone
+          # rather than converting from UTC
+          if date_time_value.offset.zero?
+            return timezone.local(
+              date_time_value.year,
+              date_time_value.month,
+              date_time_value.day,
+              date_time_value.hour,
+              date_time_value.min,
+              date_time_value.sec
+            )
+          end
+          # DateTime with explicit non-zero offset: convert to target timezone
           return date_time_value.in_time_zone(timezone)
 
         elsif date_time_value.is_a?(Icalendar::Values::Date)
@@ -325,6 +420,10 @@ module Icalendar
         elsif date_time_value.is_a?(Date)
           return _date_to_time_with_zone(date_time_value, timezone)
 
+        elsif date_time_value.is_a?(Time)
+          # Preserve Time's timezone by converting to UTC first, then to target timezone
+          return timezone.at(date_time_value.getutc)
+
         elsif date_time_value.respond_to?(:to_time)
           return timezone.at(date_time_value.to_time)
 
@@ -353,10 +452,11 @@ module Icalendar
       # @return [ActiveSupport::TimeZone] the unique timezone used in this component
       def component_timezone
         # let's try sequentially, the first non-nil wins.
-        timezone ||= _extract_timezone(_dtend)
-        timezone ||= _extract_timezone(_dtstart)
-        timezone ||= _extract_timezone(_due)
+        timezone ||= _extract_explicit_timezone(_dtend)
+        timezone ||= _extract_explicit_timezone(_dtstart)
+        timezone ||= _extract_explicit_timezone(_due)
         timezone ||= _extract_calendar_timezone
+        timezone ||= _guess_system_timezone
 
         # as a last resort we'll use the Coordinated Universal Time (UTC).
         timezone || ActiveSupport::TimeZone['UTC']
@@ -373,7 +473,6 @@ module Icalendar
         return nil unless parent.is_a?(Icalendar::Calendar)
         calendar_timezones = parent.timezones
         calendar_timezones.each do |tz|
-          break unless tz.valid?(true)
           ugly_tzid = tz.tzid
           break unless ugly_tzid
           tzid = Array(ugly_tzid).first.to_s.gsub(/^(["'])|(["'])$/, '')
@@ -387,14 +486,24 @@ module Icalendar
       # rubocop:enable Metrics/CyclomaticComplexity
 
       ##
-      # Get the timezone from the given object trying different methods to find an indication in the object.
-      # @param [Object] date_time an object from which we shall determine the time zone.
-      # @return [ActiveSupport::TimeZone, nil] the timezone used by the parameter or nil if no timezone has been set.
+      # Extracts an explicitly set timezone from the given object.
+      #
+      # This method only returns a timezone if it was explicitly specified through:
+      # - An iCalendar TZID parameter (e.g., tzid: 'Europe/Berlin')
+      # - An existing ActiveSupport::TimeWithZone object
+      # - A wrapped value that is already a TimeWithZone
+      #
+      # Unlike _guess_timezone_from_offset, this method does NOT guess or infer
+      # timezones from UTC offsets. It returns nil if no explicit timezone is found.
+      #
+      # @param date_time [Object] an object from which to extract the timezone.
+      #   Typically, an Icalendar::Value, Time, DateTime, or ActiveSupport::TimeWithZone.
+      # @return [ActiveSupport::TimeZone, nil] the explicitly set timezone, or nil if none found.
       # @api private
-      def _extract_timezone(date_time)
-        timezone ||= _extract_ical_time_zone(date_time) # try with ical parameter
-        timezone ||= _extract_act_sup_timezone(date_time) # is the given value already ActiveSupport::TimeWithZone?
-        timezone || _extract_value_time_zone(date_time) # is the ical.value of type ActiveSupport::TimeWithZone?
+      def _extract_explicit_timezone(date_time)
+        timezone ||= _extract_ical_time_zone(date_time)      # try with ical TZID parameter (most specific)
+        timezone ||= _extract_act_sup_timezone(date_time)    # is the given value already ActiveSupport::TimeWithZone?
+        timezone || _extract_value_time_zone(date_time)      # is the ical.value of type ActiveSupport::TimeWithZone?
       end
 
       ##
@@ -419,6 +528,51 @@ module Icalendar
         ical_value.value.time_zone
       end
 
+      ##
+      # Guesses the corresponding ActiveSupport timezone from a given time object's UTC offset.
+      # This method extracts the UTC offset from objects that respond to :utc_offset
+      # (such as Time, DateTime, or their wrapped values in Icalendar::Values)
+      # and matches it to an equivalent ActiveSupport::TimeZone.
+      #
+      # Note: Since multiple timezones can share the same UTC offset (e.g., Berlin,
+      # Amsterdam, Paris all use +01:00), this method returns an arbitrary timezone
+      # with the matching offset - hence "guess" rather than "extract".
+      #
+      # If the input does not respond to :utc_offset or an error occurs during processing,
+      # the method returns nil.
+      #
+      # @param date_time [Object] the object to extract the UTC offset from.
+      #   Should respond to :utc_offset (e.g., Time, DateTime, Icalendar::Values::DateTime).
+      # @return [ActiveSupport::TimeZone, nil] an ActiveSupport::TimeZone matching the UTC offset,
+      #   or nil if no match is found or an error occurs.
+      # @api private
+      def _guess_timezone_from_offset(date_time)
+        # Extract value from Icalendar::Values::DateTime if needed
+        value = date_time.is_a?(Icalendar::Value) && date_time.respond_to?(:value) ? date_time.value : date_time
+
+        return nil unless value.respond_to?(:utc_offset)
+
+        # Get the timezone offset from the Time or DateTime object
+        offset_seconds = value.utc_offset
+        return nil unless offset_seconds.is_a?(Integer)
+
+        # First try: check if the system's default timezone matches the offset
+        system_tz = _guess_system_timezone
+
+        # Return `system timezone` if it matches the offset
+        return system_tz if system_tz && system_tz.now.utc_offset == offset_seconds
+
+        # Fallback: find any timezone matching the offset
+        # For offset 0, always use UTC to avoid ambiguous timezones with DST
+        if offset_seconds.zero?
+          ActiveSupport::TimeZone['UTC']
+        else
+          ActiveSupport::TimeZone[offset_seconds]
+        end
+      rescue StandardError
+        nil
+      end
+
       ##
       # Get the timezone from the given object, assuming it can be extracted from ical params.
       # @param [Icalendar::Value] ical_value an ical value that (probably) supports a time zone identifier.
@@ -427,11 +581,72 @@ module Icalendar
       def _extract_ical_time_zone(ical_value)
         return nil unless ical_value.is_a?(Icalendar::Value)
         return nil unless ical_value.respond_to?(:ical_params)
-        ugly_tzid = ical_value.ical_params.fetch('tzid', nil)
+
+        ical_params = ical_value.ical_params
+        return nil unless ical_params
+
+        ugly_tzid = ical_params['tzid'] || ical_params[:tzid] || ical_params['TZID'] || ical_params[:TZID]
         return nil if ugly_tzid.nil?
+
         tzid = Array(ugly_tzid).first.to_s.gsub(/^(["'])|(["'])$/, '')
+        return nil if tzid.empty?
+
         ActiveSupport::TimeZone[tzid]
+      rescue StandardError
+        # Uncomment for debugging icalendar gem compatibility issues:
+        # warn "[icalendar-rrule] Failed to extract timezone: #{e.message}"
+        nil
       end
+
+      ##
+      # Attempts to determine the system's timezone.
+      # Tries multiple methods in order of reliability.
+      #
+      # @return [ActiveSupport::TimeZone, nil] the system timezone or nil if it cannot be determined.
+      # @api private
+      def _guess_system_timezone
+        # Method 1: Rails/ActiveSupport Time.zone (most reliable if set)
+        return Time.zone if Time.zone.is_a?(ActiveSupport::TimeZone)
+
+        # Method 2: ENV['TZ'] environment variable
+        if ENV['TZ']
+          tz = ActiveSupport::TimeZone[ENV['TZ']]
+          return tz if tz
+        end
+
+        # Method 3: Try TZInfo if available (optional dependency)
+        begin
+          require 'tzinfo'
+          tz_identifier = TZInfo::Timezone.default_timezone.identifier
+          tz = ActiveSupport::TimeZone[tz_identifier]
+          return tz if tz
+        rescue LoadError, StandardError
+          # TZInfo not available or failed, continue
+        end
+
+        # Method 4: Read /etc/timezone on Linux (Debian/Ubuntu style)
+        if File.readable?('/etc/timezone')
+          tz_name = File.read('/etc/timezone').strip
+          tz = ActiveSupport::TimeZone[tz_name]
+          return tz if tz
+        end
+
+        # Method 5: Parse /etc/localtime symlink (common on many Unix systems)
+        if File.symlink?('/etc/localtime')
+          link = File.readlink('/etc/localtime')
+          # Extract timezone name from path like /usr/share/zoneinfo/Europe/Berlin
+          if link =~ %r{zoneinfo/(.+)$}
+            tz = ActiveSupport::TimeZone[$1]
+            return tz if tz
+          end
+        end
+
+        nil
+      rescue StandardError
+        nil
+      end
+
+
     end
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: icalendar-rrule
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.2.0
 platform: ruby
 authors:
 - Harald Postner
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-07-11 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -149,6 +148,7 @@ files:
 - ".rubocop.yml"
 - ".travis.yml"
 - ".yardopts"
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -167,7 +167,6 @@ metadata:
   homepage_uri: https://github.com/free-creations/icalendar-rrule
   source_code_uri: https://github.com/free-creations/icalendar-rrule
   bug_tracker_uri: https://github.com/free-creations/icalendar-rrule/issues
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -182,8 +181,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 4.0.1
 specification_version: 4
 summary: Helper for ICalendars with recurring events.
 test_files: []