active-icalendar-events 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d892e9c6fe0c2ed7de91e9f085aa7e812901b6ddce53184928d6be5482a2a3b
-  data.tar.gz: 3ab320fe7a381d9361a50a629eeafdcae8e581b7695cdbc514b140e77fb11171
+  metadata.gz: 2c58972dd8113dffe13dc9434ac99480bf4bbffcc6013e8bbc082a38e0487729
+  data.tar.gz: 29e515e96bad5067907bcf7b43bf375ce2a01df43de0d743f7bb31c52566f483
 SHA512:
-  metadata.gz: 8a702e4fdec5d0474469d5445ab6eb218a54cebfce69d40872c7c75e5a3328666e1e6e917e6073ea379effc52bc6fc660c662e09442f332d1cf955997b23d3d8
-  data.tar.gz: 5956bb66a7955f25126cd861fb77e0386d8ee2cd073c7d36468007a4879185b4b0b8ce9599f2dbc62e87516bdbb2263e36ed706c68afc397c5a2145757bd11ce
+  metadata.gz: dea7414593d274bdb9c3f20e27e3ae12c1eca6764e8ef0cee122c21562edc36ab67977d4809d3fe19abd0fb9c771aaf4a491db8ae0aaed2279598a7be0daeac1
+  data.tar.gz: c9c1321759cd3080f79572e3ddc595f8b066a8422215dc27479ef1c547e84d1e10ae05e24f0a0687cc8a81ceffa2d5f477d308ebd24a8a6ffb8cef08de6e9adf

data/lib/{active-icalendar-events.rb → 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,22 +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 ||= 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 ||= 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: e.dtstart,
-        event_end: e.dtend,
+        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
@@ -118,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
@@ -133,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
@@ -141,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
@@ -177,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) ||
@@ -189,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
@@ -202,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
 
@@ -238,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
@@ -276,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
@@ -285,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
@@ -298,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
@@ -313,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
@@ -321,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
@@ -337,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,
@@ -392,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.1
+  version: 0.2.0
 platform: ruby
 authors:
 - William Starling
@@ -44,7 +44,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/active-icalendar-events.rb
+- lib/active_icalendar_events.rb
 homepage: https://github.com/foygl/active-icalendar-events
 licenses:
 - MIT