cal-invite 0.1.1 → 0.1.3

data/lib/cal_invite/event.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
-
 # lib/cal_invite/event.rb
+require 'digest'
+
 module CalInvite
   class Event
     attr_accessor :title,
@@ -13,36 +14,117 @@ module CalInvite
                   :timezone,
                   :show_attendees,
                   :notes,
-                  :multi_day_sessions
+                  :multi_day_sessions,
+                  :all_day
 
     def initialize(attributes = {})
       @show_attendees = attributes.delete(:show_attendees) || false
       @timezone = attributes.delete(:timezone) || 'UTC'
       @multi_day_sessions = attributes.delete(:multi_day_sessions) || []
+      @all_day = attributes.delete(:all_day) || false
 
       attributes.each do |key, value|
         send("#{key}=", value) if respond_to?("#{key}=")
       end
+
+      validate!
     end
 
-    def calendar_url(provider)
-      provider_class = CalInvite::Providers.const_get(provider.to_s.camelize)
+    def generate_calendar_url(provider)
+      validate!
+
+      if caching_enabled?
+        cache_key = cache_key_for(provider)
+        cached_url = fetch_from_cache(cache_key)
+        return cached_url if cached_url
+      end
+
+      # Generate the URL
+      provider_class = CalInvite::Providers.const_get(capitalize_provider(provider.to_s))
       generator = provider_class.new(self)
-      generator.generate
+      url = generator.generate
+
+      # Cache the result if caching is enabled
+      write_to_cache(cache_key, url) if caching_enabled?
+
+      url
     end
 
-    # Convert a UTC time to event's timezone
-    def localize_time(time)
-      return time unless time
-      time.in_time_zone(timezone)
+    def update_attributes(new_attributes)
+      new_attributes.each do |key, value|
+        send("#{key}=", value) if respond_to?("#{key}=")
+      end
+
+      invalidate_cache if caching_enabled?
+      validate!
+    end
+
+    private
+
+    def capitalize_provider(string)
+      string.split('_').map(&:capitalize).join
+    end
+
+    def validate!
+      raise ArgumentError, "Title is required" if title.nil? || title.strip.empty?
+
+      unless all_day
+        raise ArgumentError, "Start time is required for non-all-day events" if start_time.nil?
+        raise ArgumentError, "End time is required for non-all-day events" if end_time.nil?
+      end
+    end
+
+    def caching_enabled?
+      CalInvite.configuration &&
+        CalInvite.configuration.respond_to?(:cache_store) &&
+        CalInvite.configuration.cache_store
+    end
+
+    def cache_key_for(provider)
+      return nil unless caching_enabled?
+
+      attributes_hash = Digest::MD5.hexdigest(
+        [
+          title,
+          start_time&.to_i,
+          end_time&.to_i,
+          description,
+          location,
+          url,
+          attendees,
+          timezone,
+          show_attendees,
+          notes,
+          multi_day_sessions,
+          all_day,
+          provider
+        ].map(&:to_s).join('|')
+      )
+
+      "cal_invite:event:#{attributes_hash}"
+    end
+
+    def fetch_from_cache(key)
+      return nil unless key && caching_enabled?
+      CalInvite.configuration.cache_store.read(key)
+    end
+
+    def write_to_cache(key, value)
+      return unless key && caching_enabled?
+
+      expires_in = CalInvite.configuration&.cache_expires_in
+      CalInvite.configuration.cache_store.write(
+        key,
+        value,
+        expires_in: expires_in
+      )
     end
 
-    # Get all event sessions (including multi-day)
-    def sessions
-      return [@start_time, @end_time] if multi_day_sessions.empty?
+    def invalidate_cache
+      return unless caching_enabled?
 
-      multi_day_sessions.map do |session|
-        [session[:start_time], session[:end_time]]
+      if CalInvite.configuration.cache_store.respond_to?(:delete_matched)
+        CalInvite.configuration.cache_store.delete_matched("cal_invite:event:*")
       end
     end
   end

data/lib/cal_invite/providers/base_provider.rb

@@ -1,44 +1,66 @@
-# frozen_string_literal: true
-
-# lib/cal_invite/providers/base_provider.rb
-module CalInvite
-  module Providers
-    class BaseProvider
-      attr_reader :event
-
-      def initialize(event)
-        @event = event
-      end
-
-      def generate
-        raise NotImplementedError, "#{self.class} must implement #generate"
-      end
-
-      protected
-
-      def url_encode(str)
-        URI.encode_www_form_component(str.to_s)
-      end
-
-      def format_description
-        parts = []
-        parts << event.description if event.description
-        parts << "Notes: #{event.notes}" if event.notes
-        parts << "URL: #{event.url}" if event.url
-        parts.join("\n\n")
-      end
-
-      def format_location
-        return event.url if event.url && !event.location
-        return event.location if event.location && !event.url
-        return "#{event.location}\n#{event.url}" if event.location && event.url
-        nil
-      end
-
-      def attendees_list
-        return [] unless event.show_attendees && event.attendees&.any?
-        event.attendees
-      end
+# app/lib/base_provider.rb
+class BaseProvider
+  attr_reader :event
+
+  def initialize(event)
+    @event = event
+  end
+
+  def generate
+    raise NotImplementedError, "#{self.class} must implement #generate"
+  end
+
+  protected
+
+  def url_encode(str)
+    URI.encode_www_form_component(str.to_s)
+  end
+
+  # Format the event description
+  # @return [String, nil] The formatted description or nil if no content
+  def format_description
+    parts = []
+    parts << event.description if event.description
+    parts << "Notes: #{event.notes}" if event.notes
+    parts.join("\n\n")
+  end
+
+  # Get just the physical location
+  # @return [String, nil] The location or nil if not present
+  def format_location
+    event.location
+  end
+
+  # Get the URL for virtual meetings
+  # @return [String, nil] The URL or nil if not present
+  def format_url
+    event.url
+  end
+
+  # Format description including URL if present
+  # @return [String, nil] The formatted description with URL
+  def format_description_with_url
+    parts = []
+    parts << format_description if format_description
+    parts << "Virtual Meeting URL: #{format_url}" if format_url
+    parts.join("\n\n")
+  end
+
+  def add_optional_params(params)
+    params[:description] = url_encode(format_description_with_url) if format_description || format_url
+    params[:location] = url_encode(format_location) if format_location
+
+    if event.show_attendees && event.attendees&.any?
+      params[:attendees] = event.attendees.join(',')
     end
+
+    params
+  end
+
+  # Get the list of attendees if showing attendees is enabled
+  # @return [Array<String>] The list of attendees or empty array if disabled/none present
+  def attendees_list
+    return [] unless event.show_attendees && event.attendees&.any?
+    event.attendees
   end
 end

data/lib/cal_invite/providers/google.rb

@@ -4,11 +4,9 @@
 module CalInvite
   module Providers
     class Google < BaseProvider
-      BASE_URL = "https://calendar.google.com/calendar/render"
-
       def generate
-        if event.multi_day_sessions.any?
-          generate_multi_day_event
+        if event.all_day
+          generate_all_day_event
         else
           generate_single_event
         end
@@ -16,50 +14,59 @@ module CalInvite
 
       private
 
-      def generate_single_event
+      def generate_all_day_event
         params = {
-          action: "TEMPLATE",
-          text: event.title,
-          dates: format_dates(event.start_time, event.end_time),
-          details: format_description,
-          location: format_location,
-          ctz: event.timezone
+          action: 'TEMPLATE',
+          text: url_encode(event.title),
+          dates: format_all_day_dates
         }
 
-        if attendees_list.any?
-          params[:add] = attendees_list.join(',')
-        end
-
-        "#{BASE_URL}?#{URI.encode_www_form(params)}"
+        add_optional_params(params)
+        build_url(params)
       end
 
-      def generate_multi_day_event
-        # For multi-day events, Google Calendar supports recurring events
-        sessions = event.multi_day_sessions.map do |session|
-          format_dates(session[:start_time], session[:end_time])
-        end
-
+      def generate_single_event
         params = {
-          action: "TEMPLATE",
-          text: event.title,
-          dates: sessions.join(','),
-          details: format_description,
-          location: format_location,
-          ctz: event.timezone
+          action: 'TEMPLATE',
+          text: url_encode(event.title),
+          dates: format_dates
         }
 
-        if attendees_list.any?
-          params[:add] = attendees_list.join(',')
-        end
+        add_optional_params(params)
+        build_url(params)
+      end
+
+      def format_all_day_dates
+        # For all-day events, use current date if no start_time specified
+        start_date = event.start_time || Time.now
+        end_date = event.end_time || (start_date + 86400) # Add one day if no end_time
+
+        "#{start_date.strftime('%Y%m%d')}/#{end_date.strftime('%Y%m%d')}"
+      end
 
-        "#{BASE_URL}?#{URI.encode_www_form(params)}"
+      def format_dates
+        raise ArgumentError, "Start time is required" unless event.start_time
+        raise ArgumentError, "End time is required" unless event.end_time
+
+        start_time = event.start_time
+        end_time = event.end_time
+
+        "#{start_time.utc.strftime('%Y%m%dT%H%M%SZ')}/#{end_time.utc.strftime('%Y%m%dT%H%M%SZ')}"
       end
 
-      def format_dates(start_time, end_time)
-        start_time = event.localize_time(start_time)
-        end_time = event.localize_time(end_time)
+      def add_optional_params(params)
+        description_parts = []
+        description_parts << format_description if format_description
+        description_parts << "Virtual Meeting URL: #{format_url}" if format_url
+        params[:details] = url_encode(description_parts.join("\n\n")) if description_parts.any?
+
+        params[:location] = url_encode(format_location) if format_location
+        params
+      end
 
-        "#{start_time.strftime('%Y%m%dT%H%M%S')}/#{end_time.strftime('%Y%m%dT%H%M%S')}"
+      def build_url(params)
+        query = params.map { |k, v| "#{k}=#{v}" }.join('&')
+        "https://calendar.google.com/calendar/render?#{query}"
       end
     end
   end

data/lib/cal_invite/providers/ical.rb

@@ -8,61 +8,103 @@ module CalInvite
         [
           "BEGIN:VCALENDAR",
           "VERSION:2.0",
-          "PRODID:-//CalInvite//EN",
+          "PRODID:-//CalInvite//Ruby//EN",
+          "CALSCALE:GREGORIAN",
+          "METHOD:PUBLISH",
+          generate_timezone,
           generate_events,
           "END:VCALENDAR"
-        ].flatten.join("\r\n")
+        ].compact.join("\r\n")
       end
 
       private
 
       def generate_events
         if event.multi_day_sessions.any?
-          event.multi_day_sessions.map { |session| generate_vevent(session[:start_time], session[:end_time]) }
+          event.multi_day_sessions.map { |session| generate_vevent(session) }.join("\r\n")
         else
-          [generate_vevent(event.start_time, event.end_time)]
+          generate_vevent
         end
       end
 
-      def generate_vevent(start_time, end_time)
-        vevent = [
-          "BEGIN:VEVENT",
-          "UID:#{generate_uid}",
-          "DTSTAMP:#{format_time(Time.now)}",
-          "DTSTART;TZID=#{event.timezone}:#{format_time(start_time)}",
-          "DTEND;TZID=#{event.timezone}:#{format_time(end_time)}",
-          "SUMMARY:#{event.title}",
-          "DESCRIPTION:#{format_description}",
-        ]
-
-        if format_location
-          vevent << "LOCATION:#{format_location}"
-        end
+      def generate_vevent(session = nil)
+        lines = ["BEGIN:VEVENT"]
+
+        if event.all_day
+          start_date = event.start_time || Time.now
+          end_date = event.end_time || (start_date + 86400)
+
+          lines << "DTSTART;VALUE=DATE:#{format_date(start_date)}"
+          lines << "DTEND;VALUE=DATE:#{format_date(end_date)}"
+        else
+          start_time = session ? session[:start_time] : event.start_time
+          end_time = session ? session[:end_time] : event.end_time
 
-        if event.url
-          vevent << "URL:#{event.url}"
+          raise ArgumentError, "Start time is required for non-all-day events" unless start_time
+          raise ArgumentError, "End time is required for non-all-day events" unless end_time
+
+          lines << "DTSTART;TZID=#{event.timezone}:#{format_local_time(start_time)}"
+          lines << "DTEND;TZID=#{event.timezone}:#{format_local_time(end_time)}"
         end
 
-        if attendees_list.any?
-          attendees_list.each do |attendee|
-            vevent << "ATTENDEE;RSVP=TRUE:mailto:#{attendee}"
+        # Required fields
+        lines.concat([
+          "SUMMARY:#{escape_text(event.title)}",
+          "UID:#{generate_uid}",
+          "DTSTAMP:#{format_timestamp(Time.now.utc)}"
+        ])
+
+        # Optional fields
+        lines << "DESCRIPTION:#{escape_text(format_description)}" if format_description
+        lines << "LOCATION:#{escape_text(format_location)}" if format_location
+        lines << "URL:#{escape_text(format_url)}" if format_url
+
+        # Attendees
+        if attendees = attendees_list
+          attendees.each do |attendee|
+            lines << "ATTENDEE;RSVP=TRUE:mailto:#{attendee}"
           end
         end
 
-        vevent << "END:VEVENT"
-        vevent
+        lines << "END:VEVENT"
+        lines.join("\r\n")
+      end
+
+      def generate_timezone
+        return nil if event.all_day # No timezone needed for all-day events
+
+        [
+          "BEGIN:VTIMEZONE",
+          "TZID:#{event.timezone}",
+          "END:VTIMEZONE"
+        ].join("\r\n")
       end
 
       def generate_uid
         "#{Time.now.to_i}-#{SecureRandom.hex(8)}@cal-invite"
       end
 
-      def format_time(time)
-        event.localize_time(time).strftime("%Y%m%dT%H%M%S")
+      def format_date(time)
+        time.strftime("%Y%m%d")
+      end
+
+      def format_local_time(time)
+        # All times are already in UTC, just format them
+        time.strftime("%Y%m%dT%H%M%S")
+      end
+
+      def format_timestamp(time)
+        time.strftime("%Y%m%dT%H%M%SZ")
       end
 
       def escape_text(text)
-        text.to_s.gsub(/[,;\\]/) { |match| "\\#{match}" }
+        return '' if text.nil?
+
+        text.to_s
+            .gsub('\\', '\\\\')
+            .gsub("\n", '\\n')
+            .gsub(',', '\\,')
+            .gsub(';', '\\;')
       end
     end
   end

data/lib/cal_invite/providers/ics.rb

@@ -13,8 +13,9 @@ module CalInvite
           "METHOD:PUBLISH"
         ]
 
-        # Add events (either single or multiple sessions)
-        if event.multi_day_sessions.any?
+        if event.all_day
+          calendar_lines.concat(generate_all_day_event)
+        elsif event.multi_day_sessions.any?
           event.multi_day_sessions.each do |session|
             calendar_lines.concat(generate_vevent(session[:start_time], session[:end_time]))
           end
@@ -28,47 +29,70 @@ module CalInvite
 
       private
 
+      def generate_all_day_event
+        vevent = [
+          "BEGIN:VEVENT",
+          "UID:#{generate_uid}",
+          "DTSTAMP:#{format_timestamp(Time.now.utc)}",
+          "DTSTART;VALUE=DATE:#{format_date(event.start_time)}",
+          "DTEND;VALUE=DATE:#{format_date(event.end_time)}",
+          "SUMMARY:#{escape_text(event.title)}"
+        ]
+
+        add_optional_fields(vevent)
+        vevent << "END:VEVENT"
+        vevent
+      end
+
       def generate_vevent(start_time, end_time)
         vevent = [
           "BEGIN:VEVENT",
           "UID:#{generate_uid}",
-          "DTSTAMP:#{format_timestamp(Time.now)}",
+          "DTSTAMP:#{format_timestamp(Time.now.utc)}",
           "DTSTART;TZID=#{event.timezone}:#{format_local_timestamp(start_time)}",
           "DTEND;TZID=#{event.timezone}:#{format_local_timestamp(end_time)}",
           "SUMMARY:#{escape_text(event.title)}"
         ]
 
-        # Add description (including notes if present)
-        if desc = format_description
-          vevent << "DESCRIPTION:#{escape_text(desc)}"
+        add_optional_fields(vevent)
+        vevent << "END:VEVENT"
+        vevent
+      end
+
+      def add_optional_fields(vevent)
+        description_parts = []
+        description_parts << format_description if format_description
+
+        if description_parts.any?
+          vevent << "DESCRIPTION:#{escape_text(description_parts.join('\n\n'))}"
         end
 
-        # Add location and/or URL
-        if event.location
-          vevent << "LOCATION:#{escape_text(event.location)}"
+        if location = format_location
+          vevent << "LOCATION:#{escape_text(location)}"
         end
 
-        if event.url
-          vevent << "URL:#{escape_text(event.url)}"
+        if url = format_url
+          vevent << "URL:#{escape_text(url)}"
         end
 
-        # Add attendees if showing is enabled
         if attendees_list.any?
           attendees_list.each do |attendee|
             vevent << "ATTENDEE;RSVP=TRUE:mailto:#{attendee}"
           end
         end
-
-        vevent << "END:VEVENT"
-        vevent
       end
 
       def format_timestamp(time)
         time.utc.strftime("%Y%m%dT%H%M%SZ")
       end
 
+      def format_date(time)
+        time.strftime("%Y%m%d")
+      end
+
       def format_local_timestamp(time)
-        event.localize_time(time).strftime("%Y%m%dT%H%M%S")
+        # All times are already in UTC, just format them
+        time.strftime("%Y%m%dT%H%M%S")
       end
 
       def generate_uid
@@ -77,13 +101,12 @@ module CalInvite
 
       def escape_text(text)
         return '' if text.nil?
-
         text.to_s
             .gsub('\\', '\\\\')
             .gsub("\n", '\\n')
             .gsub(',', '\\,')
             .gsub(';', '\\;')
-        end
+      end
     end
   end
 end