active-icalendar-events 0.1.2 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 981c99140882554d70998f2b1225ce89cb47b80fb7471172c62c215204aecdb5
-  data.tar.gz: 5d58a68cb6195024aedb6a0d461c8c03a98a1f88ad5d4c0f0250e4fe08e5d077
+  metadata.gz: ee38fd75cc71289c8cf434fcf1d107f00619e3fd1b4556a775ea8c62d7ec129d
+  data.tar.gz: 64c6215c1072a70e6d67f50c5040c1e358a7320162c05ef0851a433b40b356b3
 SHA512:
-  metadata.gz: 426bb70b73ab75023013c15040498a1fc69605c5c39f08d06a83457e8e29467074064c7058083dd7223d4afad2be5a3d5c281d8a289b79d36560eff124b57ad4
-  data.tar.gz: be2600c740997701ffeab23b6eb51e844cefe31912f8c7baa9b383501a4505e50381e52c0fa844be76aad25ca2591403770999809ff0e7d0f88974f15b435083
+  metadata.gz: cc21a38b8102ec9ae3983c040f897ec73b15188da380f8a6ebcfb08163b80157f0e2e7b05c6dfd5a7c7a6bc0fe4255c27d79ee99b20d2e34c7888f9a936c7336
+  data.tar.gz: d68e25d312753fe97b67c5471a78fb7172ca29280cafa298c48fddce2400601a77824ef125e40c1ef07266948d86b9b1266591f2ec440090558bd96b2e877a95

data/lib/active-icalendar-events.rb

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'active_support'
 require 'active_support/core_ext'
@@ -51,36 +52,36 @@ module ActiveIcalendarEvents
     active_events = Set.new
 
     format_icalendar_data(icalendar_data).each do |_, events|
-      recurrence_definition = events.select { |e|
+      recurrence_definition = events.select do |e|
         !e[:recurrence_rule].empty? || !e[:recurrence_dates].empty?
-      }
+      end
       if recurrence_definition.size > 1
-        raise RuntimeError, 'Should only have one event that defines the recurrence in a group'
+        raise 'Should only have one event that defines the recurrence in a group'
       elsif recurrence_definition.size == 1
         r = recurrence_definition.first
         if r[:recurrence_rule].size > 1
-          raise RuntimeError, 'Multiple recurrence rules not supported'
+          raise 'Multiple recurrence rules not supported'
         elsif r[:recurrence_rule].size == 1
           # TODO: Validate the overrides
           active_events << get_active_event_for_datetime(
-            :datetime => datetime,
-            :name => r[:name],
-            :event_start => r[:event_start],
-            :event_end => r[:event_end],
-            :recurrence_rule => r[:recurrence_rule].first,
-            :recurrence_dates => r[:recurrence_dates],
-            :excluding_dates => r[:excluding_dates],
-            :overrides => events.reject { |e| e == r }.group_by { |e| e[:recurrence_id] }
+            datetime: datetime,
+            name: r[:name],
+            event_start: r[:event_start],
+            event_end: r[:event_end],
+            recurrence_rule: r[:recurrence_rule].first,
+            recurrence_dates: r[:recurrence_dates],
+            excluding_dates: r[:excluding_dates],
+            overrides: events.reject { |e| e == r }.group_by { |e| e[:recurrence_id] }
           )
         else
           # TODO: Haven't bothered implementing this as Google Calendar doesn't seem to use these
-          raise RuntimeError, 'Not yet implemented when only recurrence_dates are provided'
+          raise 'Not yet implemented when only recurrence_dates are provided'
         end
       else
         # Non reccurring events
-        events.each { |e|
-          active_events.add(e[:name]) if is_event_active?(datetime, e[:event_start].to_time, e[:event_end].to_time)
-        }
+        events.each do |e|
+          active_events.add(e[:name]) if event_active?(datetime, e[:event_start], e[:event_end])
+        end
       end
     end
 
@@ -90,34 +91,67 @@ module ActiveIcalendarEvents
     active_events.to_a
   end
 
+  def timezone_for_event(event)
+    if event.parent.timezones.empty?
+      ActiveSupport::TimeZone.new(event.parent.custom_properties['x_wr_timezone'].first.to_s)
+    else
+      ActiveSupport::TimeZone.new(event.parent.timezones.first.tzid.to_s)
+    end
+  end
+
   def format_icalendar_data(icalendar_data)
-    icalendar_data.first.events.map { |e|
+    icalendar_data.first.events.map do |e|
       event_start = e.dtstart
       if event_start.is_a?(Icalendar::Values::Date)
-        timezone = ActiveSupport::TimeZone.new(e.parent.timezones.first.tzid.to_s)
+        timezone ||= timezone_for_event(e)
         event_start = timezone.local(event_start.year, event_start.month, event_start.day)
       end
 
       event_end = e.dtend
       if event_end.is_a?(Icalendar::Values::Date)
-        timezone = ActiveSupport::TimeZone.new(e.parent.timezones.first.tzid.to_s)
+        timezone ||= timezone_for_event(e)
         event_end = timezone.local(event_end.year, event_end.month, event_end.day)
       end
 
+      excluding_dates = e.exdate.map do |d|
+        if d.is_a?(Icalendar::Values::Date)
+          timezone ||= timezone_for_event(e)
+          timezone.local(d.year, d.month, d.day)
+        else
+          d
+        end
+      end
+
+      recurrence_dates = e.rdate.map do |d|
+        if d.is_a?(Icalendar::Values::Date)
+          timezone ||= timezone_for_event(e)
+          timezone.local(d.year, d.month, d.day)
+        else
+          d
+        end
+      end
+
+      e.rrule.each do |rrule|
+        unless rrule.until.nil?
+          timezone ||= timezone_for_event(e)
+          rrule.until = timezone.parse(rrule.until)
+        end
+      end
+
       {
         name: e.summary,
         event_start: event_start,
         event_end: event_end,
         recurrence_rule: e.rrule,
-        recurrence_dates: e.rdate,
-        excluding_dates: e.exdate,
+        recurrence_dates: recurrence_dates,
+        excluding_dates: excluding_dates,
         recurrence_id: e.recurrence_id,
         uid: e.uid
       }
-    }.group_by { |e| e[:uid] }
+    end.group_by { |e| e[:uid] }
   end
 
-  def is_event_active?(datetime, event_start, event_end)
+  def event_active?(datetime, event_start, event_end)
     event_start <= datetime.to_time &&
       event_end > datetime.to_time
   end
@@ -130,14 +164,14 @@ module ActiveIcalendarEvents
     !count.nil? && considered_count > count
   end
 
-  def is_daily_event_active_for_datetime?(datetime,
-                                          event_start,
-                                          event_end,
-                                          until_datetime,
-                                          count,
-                                          interval,
-                                          excluding_dates,
-                                          overridden_dates)
+  def daily_event_active_for_datetime?(datetime,
+                                       event_start,
+                                       event_end,
+                                       until_datetime,
+                                       count,
+                                       interval,
+                                       excluding_dates,
+                                       overridden_dates)
     event_start_considered = event_start
     event_end_considered = event_end
     considered_count = 1
@@ -145,7 +179,7 @@ module ActiveIcalendarEvents
           !instance_count_exceeded?(considered_count, count) &&
           event_start_considered <= datetime
 
-      if is_event_active?(datetime, event_start_considered, event_end_considered)
+      if event_active?(datetime, event_start_considered, event_end_considered)
         return !excluding_dates.include?(event_start_considered) &&
                !overridden_dates.include?(event_start_considered)
       end
@@ -153,34 +187,35 @@ module ActiveIcalendarEvents
       # We consider both active dates and excluded dates for the recurrence count
       considered_count += 1
 
-      event_start_considered = event_start_considered + interval.days
-      event_end_considered = event_end_considered + interval.days
+      event_start_considered += interval.days
+      event_end_considered += interval.days
     end
 
     false
   end
 
-  def is_weekly_event_active_for_datetime?(datetime,
-                                           event_start,
-                                           event_end,
-                                           until_datetime,
-                                           count,
-                                           interval,
-                                           by_day,
-                                           excluding_dates,
-                                           overridden_dates)
+  def weekly_event_active_for_datetime?(datetime,
+                                        event_start,
+                                        event_end,
+                                        until_datetime,
+                                        count,
+                                        interval,
+                                        by_day,
+                                        excluding_dates,
+                                        overridden_dates)
     event_start_considered = event_start
     event_end_considered = event_end
     considered_count = 1
-    while !instance_count_exceeded?(considered_count, count)
+    until instance_count_exceeded?(considered_count, count)
 
+      # NOTE: Google Calendar does not appear to produce weekly events that do not specify a "by_day" array, so this path is untested
       if by_day.empty?
         if until_datetime_passed?(event_start_considered, until_datetime) ||
            event_start_considered > datetime
           return false
         end
 
-        if is_event_active?(datetime, event_start_considered, event_end_considered)
+        if event_active?(datetime, event_start_considered, event_end_considered)
           return !excluding_dates.include?(event_start_considered) &&
                  !overridden_dates.include?(event_start_considered)
         end
@@ -189,11 +224,14 @@ module ActiveIcalendarEvents
         considered_count += 1
       else
         week_event_start_considered =
-          event_start_considered.monday? ? event_start_considered :
-                                           event_start_considered.prev_occurring(:monday)
+          if event_start_considered.monday?
+            event_start_considered
+          else
+            event_start_considered.prev_occurring(:monday)
+          end
         week_event_end_considered = week_event_start_considered + (event_end.to_time - event_start.to_time).seconds
 
-        (1..7).each { |_|
+        (1..7).each do |_|
           if week_event_start_considered >= event_start
             if until_datetime_passed?(week_event_start_considered, until_datetime) ||
                instance_count_exceeded?(considered_count, count) ||
@@ -201,10 +239,10 @@ module ActiveIcalendarEvents
               return false
             end
 
-            day_code = week_event_start_considered.strftime("%^a").chop
+            day_code = week_event_start_considered.strftime('%^a').chop
 
             if by_day.include?(day_code)
-              if is_event_active?(datetime, week_event_start_considered, week_event_end_considered)
+              if event_active?(datetime, week_event_start_considered, week_event_end_considered)
                 return !excluding_dates.include?(week_event_start_considered) &&
                        !overridden_dates.include?(week_event_start_considered)
               end
@@ -214,23 +252,26 @@ module ActiveIcalendarEvents
             end
           end
 
-          week_event_start_considered = week_event_start_considered + 1.days
-          week_event_end_considered = week_event_end_considered + 1.days
-        }
+          week_event_start_considered += 1.days
+          week_event_end_considered += 1.days
+        end
       end
 
-      event_start_considered = event_start_considered + interval.weeks
-      event_end_considered = event_end_considered + interval.weeks
+      event_start_considered += interval.weeks
+      event_end_considered += interval.weeks
     end
 
     false
   end
 
+  # Get the beginning of the month, maintaining the timestamp
+  def beginning_of_month(datetime)
+    datetime - (datetime.day - 1).days
+  end
+
   def get_nth_day_in_month(datetime, day)
-    matches = day.match /^([0-9]+)([A-Z]+)$/
-    if matches.nil?
-      raise RuntimeError, "Unexpected by_day format found"
-    end
+    matches = day.match(/^([0-9]+)([A-Z]+)$/)
+    raise 'Unexpected by_day format found' if matches.nil?
 
     number, day_code = matches.captures
 
@@ -250,32 +291,30 @@ module ActiveIcalendarEvents
                 when 'SU'
                   :sunday
                 else
-                  raise RuntimeError, "Unexpected day code used"
+                  raise 'Unexpected day code used'
                 end
 
-    target_day = datetime.beginning_of_month
+    target_day = beginning_of_month(datetime)
 
-    if target_day.strftime("%^a").chop != day_code
-      target_day = target_day.next_occurring(day_label)
-    end
+    target_day = target_day.next_occurring(day_label) if target_day.strftime('%^a').chop != day_code
 
-    (2..number.to_i).each { |_|
+    (2..number.to_i).each do |_|
       target_day = target_day.next_occurring(day_label)
-    }
+    end
 
     target_day
   end
 
-  def is_monthly_event_active_for_datetime?(datetime,
-                                            event_start,
-                                            event_end,
-                                            until_datetime,
-                                            count,
-                                            interval,
-                                            by_day,
-                                            by_month_day,
-                                            excluding_dates,
-                                            overridden_dates)
+  def monthly_event_active_for_datetime?(datetime,
+                                         event_start,
+                                         event_end,
+                                         until_datetime,
+                                         count,
+                                         interval,
+                                         by_day,
+                                         by_month_day,
+                                         excluding_dates,
+                                         overridden_dates)
     # TODO: We will ignore the contents of "by_month_day" for now and assume
     #       always contains one number which is the same as the day of
     #       "event_start". We additionally assume that "by_day" will only contain
@@ -288,7 +327,7 @@ module ActiveIcalendarEvents
           !instance_count_exceeded?(considered_count, count) &&
           event_start_considered <= datetime
 
-      if is_event_active?(datetime, event_start_considered, event_end_considered)
+      if event_active?(datetime, event_start_considered, event_end_considered)
         return !excluding_dates.include?(event_start_considered) &&
                !overridden_dates.include?(event_start_considered)
       end
@@ -297,11 +336,11 @@ module ActiveIcalendarEvents
       considered_count += 1
 
       if by_day.nil? || by_day.empty?
-        event_start_considered = event_start_considered + interval.month
-        event_end_considered = event_end_considered + interval.month
+        event_start_considered += interval.month
+        event_end_considered += interval.month
       else
         event_start_considered =
-          get_nth_day_in_month(event_start_considered.beginning_of_month + interval.month,
+          get_nth_day_in_month(beginning_of_month(event_start_considered) + interval.month,
                                by_day.first)
         event_end_considered = event_start_considered + (event_end.to_time - event_start.to_time).seconds
       end
@@ -310,14 +349,14 @@ module ActiveIcalendarEvents
     false
   end
 
-  def is_yearly_event_active_for_datetime?(datetime,
-                                           event_start,
-                                           event_end,
-                                           until_datetime,
-                                           count,
-                                           interval,
-                                           excluding_dates,
-                                           overridden_dates)
+  def yearly_event_active_for_datetime?(datetime,
+                                        event_start,
+                                        event_end,
+                                        until_datetime,
+                                        count,
+                                        interval,
+                                        excluding_dates,
+                                        overridden_dates)
     event_start_considered = event_start
     event_end_considered = event_end
     considered_count = 1
@@ -325,7 +364,7 @@ module ActiveIcalendarEvents
           !instance_count_exceeded?(considered_count, count) &&
           event_start_considered <= datetime
 
-      if is_event_active?(datetime, event_start_considered, event_end_considered)
+      if event_active?(datetime, event_start_considered, event_end_considered)
         return !excluding_dates.include?(event_start_considered) &&
                !overridden_dates.include?(event_start_considered)
       end
@@ -333,8 +372,8 @@ module ActiveIcalendarEvents
       # We consider both active dates and excluded dates for the recurrence count
       considered_count += 1
 
-      event_start_considered = event_start_considered + interval.years
-      event_end_considered = event_end_considered + interval.years
+      event_start_considered += interval.years
+      event_end_considered += interval.years
     end
 
     false
@@ -349,54 +388,48 @@ module ActiveIcalendarEvents
                                     excluding_dates: [],
                                     overrides:)
     # Can return early if one of the overrides matches as they always take precendence
-    overrides.values.flatten.each { |e|
-      return e[:name] if e[:event_start] <= datetime.to_time &&
-                         e[:event_end] > datetime.to_time
-    }
+    overrides.values.flatten.each do |e|
+      return e[:name] if event_active?(datetime, e[:event_start], e[:event_end])
+    end
 
     # Can return early if one of the recurrence dates matches and is not overridden
     # Note: I've just made an assumption about how this data could be presented.
     #       Google Calendar does not seem to create rdates, only rrules.
-    (recurrence_dates - overrides.keys).each { |recurrence_event_start|
-      recurrence_event_end = recurrence_event_start + (event_end.to_time - event_start.to_time)
-      return name if is_event_active?(datetime, recurrence_event_start, recurrence_event_end)
-    }
-
-    until_datetime = nil
-    if !recurrence_rule.until.nil?
-      until_datetime = DateTime.parse(recurrence_rule.until)
+    (recurrence_dates - overrides.keys).each do |recurrence_event_start|
+      recurrence_event_end = recurrence_event_start + (event_end.to_time - event_start.to_time).seconds
+      return name if event_active?(datetime, recurrence_event_start, recurrence_event_end)
     end
 
     case recurrence_rule.frequency
-    when "DAILY"
-      return name if is_daily_event_active_for_datetime?(
+    when 'DAILY'
+      return name if daily_event_active_for_datetime?(
         datetime,
         event_start,
         event_end,
-        until_datetime,
+        recurrence_rule.until,
         recurrence_rule.count,
         recurrence_rule.interval.nil? ? 1 : recurrence_rule.interval,
         excluding_dates,
         overrides.keys
       )
-    when "WEEKLY"
-      return name if is_weekly_event_active_for_datetime?(
+    when 'WEEKLY'
+      return name if weekly_event_active_for_datetime?(
         datetime,
         event_start,
         event_end,
-        until_datetime,
+        recurrence_rule.until,
         recurrence_rule.count,
         recurrence_rule.interval.nil? ? 1 : recurrence_rule.interval,
         recurrence_rule.by_day,
         excluding_dates,
         overrides.keys
       )
-    when "MONTHLY"
-      return name if is_monthly_event_active_for_datetime?(
+    when 'MONTHLY'
+      return name if monthly_event_active_for_datetime?(
         datetime,
         event_start,
         event_end,
-        until_datetime,
+        recurrence_rule.until,
         recurrence_rule.count,
         recurrence_rule.interval.nil? ? 1 : recurrence_rule.interval,
         recurrence_rule.by_day,
@@ -404,19 +437,19 @@ module ActiveIcalendarEvents
         excluding_dates,
         overrides.keys
       )
-    when "YEARLY"
-      return name if is_yearly_event_active_for_datetime?(
+    when 'YEARLY'
+      return name if yearly_event_active_for_datetime?(
         datetime,
         event_start,
         event_end,
-        until_datetime,
+        recurrence_rule.until,
         recurrence_rule.count,
         recurrence_rule.interval.nil? ? 1 : recurrence_rule.interval,
         excluding_dates,
         overrides.keys
       )
     else
-      throw RuntimeError, "Invalid event frequency"
+      throw RuntimeError, 'Invalid event frequency'
     end
 
     nil

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active-icalendar-events
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.1
 platform: ruby
 authors:
 - William Starling