cal-invite 0.1.2 → 0.1.3

data/lib/cal_invite/event.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
-
 # lib/cal_invite/event.rb
+require 'digest'
+
 module CalInvite
-  # Represents a calendar event with its properties and validation rules
   class Event
     attr_accessor :title,
                   :start_time,
@@ -17,36 +17,12 @@ module CalInvite
                   :multi_day_sessions,
                   :all_day
 
-    # Initialize a new Event instance
-    #
-    # @param attributes [Hash] The attributes to initialize the event with
-    # @option attributes [String] :title The event title
-    # @option attributes [Time] :start_time The event start time
-    # @option attributes [Time] :end_time The event end time
-    # @option attributes [String] :description The event description
-    # @option attributes [String] :location The event location
-    # @option attributes [String] :url The event URL
-    # @option attributes [Array<String>] :attendees List of event attendees
-    # @option attributes [String] :timezone The event timezone (default: 'UTC')
-    # @option attributes [Boolean] :show_attendees Whether to show attendees (default: false)
-    # @option attributes [String] :notes Additional notes for the event
-    # @option attributes [Array<Hash>] :multi_day_sessions List of sessions for multi-day events
-    # @option attributes [Boolean] :all_day Whether this is an all-day event (default: false)
-    # @raise [ArgumentError] if required attributes are missing
     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
 
-      # Convert times to UTC before storing
-      if attributes[:start_time]
-        attributes[:start_time] = ensure_utc(attributes[:start_time])
-      end
-      if attributes[:end_time]
-        attributes[:end_time] = ensure_utc(attributes[:end_time])
-      end
-
       attributes.each do |key, value|
         send("#{key}=", value) if respond_to?("#{key}=")
       end
@@ -54,62 +30,41 @@ module CalInvite
       validate!
     end
 
-    # Generate a calendar URL for the specified provider
-    #
-    # @param provider [Symbol] The calendar provider to generate the URL for
-    # @return [String] The generated calendar URL
-    # @raise [ArgumentError] if required attributes are missing
-    def calendar_url(provider)
+    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
-    end
+      url = generator.generate
 
-    # Convert a UTC time to event's timezone
-    #
-    # @param time [Time, nil] The time to convert
-    # @return [Time, nil] The converted time in the event's timezone
-    def localize_time(time)
-      return time unless time
-      # When timezone is UTC, we should preserve the UTC time
-      # without any conversion
-      return time if timezone == 'UTC'
-      time.getlocal(timezone_offset)
-    end
-
-    # Get all event sessions including multi-day sessions
-    #
-    # @return [Array<Array<Time>>] Array of start and end time pairs
-    def sessions
-      return [@start_time, @end_time] if multi_day_sessions.empty?
+      # Cache the result if caching is enabled
+      write_to_cache(cache_key, url) if caching_enabled?
 
-      multi_day_sessions.map do |session|
-        [session[:start_time], session[:end_time]]
-      end
+      url
     end
 
-    private
+    def update_attributes(new_attributes)
+      new_attributes.each do |key, value|
+        send("#{key}=", value) if respond_to?("#{key}=")
+      end
 
-    def ensure_utc(time)
-      return nil unless time
-      time.is_a?(Time) ? time.utc : Time.parse(time.to_s).utc
+      invalidate_cache if caching_enabled?
+      validate!
     end
 
-    def timezone_offset
-      return '+00:00' if timezone == 'UTC'
-      timezone # assume timezone is already in offset format
-    end
+    private
 
     def capitalize_provider(string)
-      # Handles both simple capitalization (ical -> Ical)
-      # and compound names (office365 -> Office365)
       string.split('_').map(&:capitalize).join
     end
 
-    # Validate the event attributes
-    #
-    # @raise [ArgumentError] if required attributes are missing
     def validate!
       raise ArgumentError, "Title is required" if title.nil? || title.strip.empty?
 
@@ -118,5 +73,59 @@ module CalInvite
         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
+
+    def invalidate_cache
+      return unless caching_enabled?
+
+      if CalInvite.configuration.cache_store.respond_to?(:delete_matched)
+        CalInvite.configuration.cache_store.delete_matched("cal_invite:event:*")
+      end
+    end
   end
 end

data/lib/cal_invite/providers/base_provider.rb

@@ -1,68 +1,66 @@
-# frozen_string_literal: true
+# app/lib/base_provider.rb
+class BaseProvider
+  attr_reader :event
 
-# lib/cal_invite/providers/base_provider.rb
-module CalInvite
-  module Providers
-    # Base class for calendar providers that implements common functionality
-    # and defines the interface that all providers must implement
-    class BaseProvider
-      # @return [CalInvite::Event] The event being processed
-      attr_reader :event
+  def initialize(event)
+    @event = event
+  end
+
+  def generate
+    raise NotImplementedError, "#{self.class} must implement #generate"
+  end
 
-      # Initialize a new calendar provider
-      #
-      # @param event [CalInvite::Event] The event to generate a calendar URL for
-      def initialize(event)
-        @event = event
-      end
+  protected
 
-      # Generate a calendar URL for the event
-      # This method must be implemented by all provider subclasses
-      #
-      # @abstract
-      # @raise [NotImplementedError] if the provider class doesn't implement this method
-      def generate
-        raise NotImplementedError, "#{self.class} must implement #generate"
-      end
+  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
 
-      protected
+  # Get just the physical location
+  # @return [String, nil] The location or nil if not present
+  def format_location
+    event.location
+  end
 
-      # URL encode a string for use in calendar URLs
-      #
-      # @param str [#to_s] The string to encode
-      # @return [String] The URL encoded string
-      def url_encode(str)
-        URI.encode_www_form_component(str.to_s)
-      end
+  # Get the URL for virtual meetings
+  # @return [String, nil] The URL or nil if not present
+  def format_url
+    event.url
+  end
 
-      # Format the event description including notes and URL if present
-      #
-      # @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 << "URL: #{event.url}" if event.url
-        parts.join("\n\n")
-      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
 
-      # Format the event location, combining physical location and URL if both present
-      #
-      # @return [String, nil] The formatted location or nil if neither location nor URL present
-      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 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
 
-      # 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
+    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

@@ -55,7 +55,11 @@ module CalInvite
       end
 
       def add_optional_params(params)
-        params[:details] = url_encode(format_description) if format_description
+        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

data/lib/cal_invite/providers/ical.rb

@@ -9,16 +9,19 @@ module CalInvite
           "BEGIN:VCALENDAR",
           "VERSION:2.0",
           "PRODID:-//CalInvite//Ruby//EN",
+          "CALSCALE:GREGORIAN",
+          "METHOD:PUBLISH",
+          generate_timezone,
           generate_events,
           "END:VCALENDAR"
-        ].join("\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) }.join("\n")
+          event.multi_day_sessions.map { |session| generate_vevent(session) }.join("\r\n")
         else
           generate_vevent
         end
@@ -40,38 +43,68 @@ module CalInvite
           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:#{format_time(start_time)}"
-          lines << "DTEND:#{format_time(end_time)}"
+          lines << "DTSTART;TZID=#{event.timezone}:#{format_local_time(start_time)}"
+          lines << "DTEND;TZID=#{event.timezone}:#{format_local_time(end_time)}"
         end
 
+        # Required fields
         lines.concat([
-          "SUMMARY:#{event.title}",
-          "UID:#{generate_uid}"
+          "SUMMARY:#{escape_text(event.title)}",
+          "UID:#{generate_uid}",
+          "DTSTAMP:#{format_timestamp(Time.now.utc)}"
         ])
 
-        lines << "DESCRIPTION:#{format_description}" if format_description
-        lines << "LOCATION:#{format_location}" if format_location
+        # 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:mailto:#{attendee}"
+            lines << "ATTENDEE;RSVP=TRUE:mailto:#{attendee}"
           end
         end
 
         lines << "END:VEVENT"
-        lines.join("\n")
+        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
-        SecureRandom.uuid
+        "#{Time.now.to_i}-#{SecureRandom.hex(8)}@cal-invite"
       end
 
       def format_date(time)
         time.strftime("%Y%m%d")
       end
 
-      def format_time(time)
-        time.utc.strftime("%Y%m%dT%H%M%SZ")
+      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)
+        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

data/lib/cal_invite/providers/ics_content.rb

@@ -0,0 +1,111 @@
+# lib/cal_invite/providers/ics_content.rb
+module CalInvite
+  module Providers
+    class IcsContent < BaseProvider
+      def generate
+        calendar_lines = [
+          "BEGIN:VCALENDAR",
+          "VERSION:2.0",
+          "PRODID:-//CalInvite//EN",
+          "CALSCALE:GREGORIAN",
+          "METHOD:PUBLISH"
+        ]
+
+        if event.multi_day_sessions.any?
+          event.multi_day_sessions.each do |session|
+            calendar_lines.concat(generate_vevent(session[:start_time], session[:end_time]))
+          end
+        else
+          calendar_lines.concat(generate_vevent(event.start_time, event.end_time))
+        end
+
+        calendar_lines << "END:VCALENDAR"
+        calendar_lines.join("\r\n")
+      end
+
+      private
+
+      def generate_vevent(start_time, end_time)
+        [
+          "BEGIN:VEVENT",
+          "UID:#{generate_uid}",
+          "DTSTAMP:#{format_timestamp(Time.now.utc)}",
+          "DTSTART:#{format_timestamp(start_time)}",
+          "DTEND:#{format_timestamp(end_time)}",
+          "SUMMARY:#{escape_text(event.title)}",
+          description_line,
+          location_line,
+          url_line,
+          attendee_lines,
+          "END:VEVENT"
+        ].compact
+      end
+
+      def format_timestamp(time)
+        time.utc.strftime("%Y%m%dT%H%M%SZ")
+      end
+
+      def generate_uid
+        "#{Time.now.to_i}-#{SecureRandom.hex(8)}@cal-invite"
+      end
+
+      def escape_text(text)
+        return '' if text.nil?
+        text.to_s
+            .gsub('\\', '\\\\')
+            .gsub("\n", '\\n')
+            .gsub(',', '\\,')
+            .gsub(';', '\\;')
+      end
+
+      def description_line
+        return nil unless event.description
+        "DESCRIPTION:#{escape_text(event.description)}"
+      end
+
+      def location_line
+        return nil unless event.location
+        "LOCATION:#{escape_text(event.location)}"
+      end
+
+      def url_line
+        return nil unless event.url
+        "URL:#{escape_text(event.url)}"
+      end
+
+      def attendee_lines
+        return nil unless event.show_attendees && event.attendees&.any?
+        event.attendees.map { |attendee| "ATTENDEE;RSVP=TRUE:mailto:#{attendee}" }
+      end
+    end
+
+    # Optional download wrapper
+    module IcsDownload
+      def self.headers(filename)
+        {
+          'Content-Type' => 'text/calendar; charset=UTF-8',
+          'Content-Disposition' => "attachment; filename=#{sanitize_filename(filename)}"
+        }
+      end
+
+      def self.sanitize_filename(filename)
+        filename.gsub(/[^0-9A-Za-z.\-]/, '_')
+      end
+
+      def self.wrap_for_download(content, title)
+        filename = sanitize_filename("#{title.downcase}_#{Time.now.strftime('%Y%m%d')}.ics")
+        {
+          content: content,
+          headers: headers(filename)
+        }
+      end
+    end
+
+    # For compatibility, keep the original classes but inherit from IcsContent
+    class Ics < IcsContent
+    end
+
+    class Ical < IcsContent
+    end
+  end
+end

data/lib/cal_invite/providers/office365.rb

@@ -53,17 +53,17 @@ module CalInvite
       end
 
       def format_time(time)
-        time.utc.strftime('%Y-%m-%dT%H:%M:%S')
+        # Always use UTC format, timezone is handled by the calendar
+        time.utc.strftime('%Y-%m-%dT%H:%M:%SZ')
       end
 
       def add_optional_params(params)
-        if description = format_description
-          params[:body] = url_encode(description)
-        end
+        description_parts = []
+        description_parts << format_description if format_description
+        description_parts << "Virtual Meeting URL: #{format_url}" if format_url
+        params[:body] = url_encode(description_parts.join("\n\n")) if description_parts.any?
 
-        if location = format_location
-          params[:location] = url_encode(location)
-        end
+        params[:location] = url_encode(format_location) if format_location
 
         if attendees = attendees_list
           params[:to] = url_encode(attendees.join(';'))