cal-invite 0.1.4 → 0.2.0

data/lib/cal_invite/event.rb

@@ -11,12 +11,28 @@ require 'digest'
 # @attr_accessor [String] description The description of the event
 # @attr_accessor [String] location The location of the event
 # @attr_accessor [String] url The URL associated with the event
-# @attr_accessor [Array<String>] attendees The list of attendee email addresses
+# @attr_accessor [Array<String, Hash>] attendees Attendees as email strings, or hashes like
+#   { email:, name:, partstat: } for a display name and/or a specific RSVP status
+#   (:accepted, :declined, :tentative, :needs_action, :delegated)
 # @attr_accessor [String] timezone The timezone for the event
 # @attr_accessor [Boolean] show_attendees Whether to include attendees in calendar invites
 # @attr_accessor [String] notes Additional notes for the event
 # @attr_accessor [Array<Hash>] multi_day_sessions Sessions for multi-day events
 # @attr_accessor [Boolean] all_day Whether this is an all-day event
+# @attr_accessor [Hash] organizer The event organizer, e.g. { name: "Jane Doe", email: "jane@example.com" }
+# @attr_accessor [String] uid Stable RFC 5545 UID identifying this event across its lifecycle
+# @attr_accessor [Integer] sequence RFC 5545 SEQUENCE number; bump on every REQUEST/CANCEL update
+# @attr_accessor [Array<Float>, Hash] geo Location coordinates, e.g. [37.4595, -122.1418] or { lat:, lng: }
+# @attr_accessor [Array<Integer>] reminders Minutes-before-start values, one VALARM per entry
+# @attr_accessor [Boolean] busy Whether this event should show as busy (true) or free (false) on free/busy lookups
+# @attr_accessor [Symbol, String] visibility :public, :private, or :confidential
+# @attr_accessor [String] rrule A raw RFC 5545 recurrence rule value, e.g. "FREQ=WEEKLY;COUNT=5"
+# @attr_accessor [String] calendar_name Calendar-level display name (X-WR-CALNAME)
+# @attr_accessor [Symbol, String] importance :low, :normal, or :high — maps to the standard
+#   PRIORITY property and, for Outlook specifically, X-MICROSOFT-CDO-IMPORTANCE
+# @attr_accessor [Boolean] allow_counter Whether attendees may propose a new time. When set to
+#   false, emits X-MICROSOFT-DISALLOW-COUNTER — the one client-specific lever available for
+#   this; other clients don't expose an equivalent control
 module CalInvite
   class Event
     attr_accessor :title,
@@ -30,7 +46,18 @@ module CalInvite
                   :show_attendees,
                   :notes,
                   :multi_day_sessions,
-                  :all_day
+                  :all_day,
+                  :organizer,
+                  :uid,
+                  :sequence,
+                  :geo,
+                  :reminders,
+                  :busy,
+                  :visibility,
+                  :rrule,
+                  :calendar_name,
+                  :importance,
+                  :allow_counter
 
     # Initializes a new Event instance with the given attributes.
     #
@@ -47,6 +74,22 @@ module CalInvite
     # @option attributes [String] :notes Additional notes
     # @option attributes [Array<Hash>] :multi_day_sessions Multi-day session details
     # @option attributes [Boolean] :all_day (false) Whether it's an all-day event
+    # @option attributes [Hash] :organizer The event organizer, e.g. { name: "Jane Doe", email: "jane@example.com" }
+    # @option attributes [String] :uid A stable identifier for this event. If omitted, a random one
+    #   is generated and memoized on this instance. To update or cancel a previously sent invite,
+    #   you MUST pass the same :uid used originally — mail/calendar clients match REQUEST/CANCEL
+    #   messages to an existing event by UID, not by content.
+    # @option attributes [Integer] :sequence (0) RFC 5545 SEQUENCE number. Increment it yourself
+    #   each time you re-send a REQUEST or a CANCEL for the same :uid.
+    # @option attributes [Array<Float>, Hash] :geo Location coordinates, e.g. [37.4595, -122.1418]
+    #   or { lat:, lng: }
+    # @option attributes [Array<Integer>] :reminders Minutes-before-start values; one VALARM per entry
+    # @option attributes [Boolean] :busy (true) Whether this event shows as busy on free/busy lookups
+    # @option attributes [Symbol, String] :visibility (:public) :public, :private, or :confidential
+    # @option attributes [String] :rrule A raw RFC 5545 recurrence rule value, e.g. "FREQ=WEEKLY;COUNT=5"
+    # @option attributes [String] :calendar_name Calendar-level display name (X-WR-CALNAME)
+    # @option attributes [Symbol, String] :importance :low, :normal, or :high
+    # @option attributes [Boolean] :allow_counter (true) false emits X-MICROSOFT-DISALLOW-COUNTER
     #
     # @raise [ArgumentError] If required attributes are missing
     def initialize(attributes = {})
@@ -54,6 +97,11 @@ module CalInvite
       @timezone = attributes.delete(:timezone) || 'UTC'
       @multi_day_sessions = attributes.delete(:multi_day_sessions) || []
       @all_day = attributes.delete(:all_day) || false
+      @uid = attributes.delete(:uid) || generate_uid
+      @sequence = attributes.delete(:sequence) || 0
+      @busy = attributes.key?(:busy) ? attributes.delete(:busy) : true
+      @visibility = attributes.delete(:visibility) || :public
+      @allow_counter = attributes.key?(:allow_counter) ? attributes.delete(:allow_counter) : true
 
       attributes.each do |key, value|
         send("#{key}=", value) if respond_to?("#{key}=")
@@ -62,10 +110,26 @@ module CalInvite
       validate!
     end
 
-    # Generates a calendar URL for the specified provider.
+    # Generates a calendar URL (or, for the ics/ical/ics_content providers, raw
+    # iCalendar content) for the specified provider.
     #
     # @param provider [Symbol] The calendar provider to generate the URL for
-    # @return [String] The generated calendar URL
+    # @param method [Symbol] The iCalendar METHOD to use (:publish, :request, :cancel,
+    #   :reply, :counter, or :decline_counter). Only honored by the ics-family providers
+    #   (ics, ical, ics_content); ignored by URL-based providers.
+    #   - :request (with an {#organizer} set) produces an invite that mail clients
+    #     (Gmail, Outlook, Apple Mail) recognize and render with Accept/Decline
+    #     actions rather than as a plain attachment.
+    #   - :cancel produces a cancellation (STATUS:CANCELLED) for a previously sent
+    #     :request. Reuse the same {#uid} and bump {#sequence} so clients match it
+    #     to the original invite instead of creating a new event.
+    #   - :reply carries an attendee's own PARTSTAT back to the organizer.
+    #   - :counter carries an attendee's proposed new {#start_time}/{#end_time} back
+    #     to the organizer, keeping the original {#uid}/{#sequence}. Client support for
+    #     rendering this as an actionable UI is inconsistent — see CONFIGURATION.md's
+    #     "Attendee-proposed reschedules (COUNTER)".
+    #   - :decline_counter is the organizer rejecting a :counter proposal.
+    # @return [String] The generated calendar URL or content
     # @raise [ArgumentError] If required event attributes are missing
     #
     # @example Generate a Google Calendar URL
@@ -73,18 +137,27 @@ module CalInvite
     #
     # @example Generate an Outlook Calendar URL
     #   event.generate_calendar_url(:outlook)
-    def generate_calendar_url(provider)
+    #
+    # @example Generate an RFC 5545 meeting request for emailing as an invite
+    #   event.organizer = { name: "Jane Doe", email: "jane@example.com" }
+    #   event.generate_calendar_url(:ics, method: :request)
+    #
+    # @example Cancel a previously sent invite
+    #   event.uid = "the-original-uid@cal-invite"  # must match the original REQUEST
+    #   event.sequence = 1                          # incremented from the original
+    #   event.generate_calendar_url(:ics, method: :cancel)
+    def generate_calendar_url(provider, method: :publish)
       validate!
 
       if caching_enabled?
-        cache_key = cache_key_for(provider)
+        cache_key = cache_key_for(provider, method)
         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 = provider_class.new(self, method: method)
       url = generator.generate
 
       # Cache the result if caching is enabled
@@ -115,6 +188,14 @@ module CalInvite
 
     private
 
+    # Generates a stable unique identifier for this event.
+    # Format: timestamp-randomhex@cal-invite
+    #
+    # @return [String] The generated UID
+    def generate_uid
+      "#{Time.now.to_i}-#{SecureRandom.hex(8)}@cal-invite"
+    end
+
     # Capitalizes each part of the provider name.
     #
     # @param string [String] The provider name to capitalize
@@ -149,8 +230,9 @@ module CalInvite
     # Generates a cache key for the event and provider combination.
     #
     # @param provider [Symbol] The calendar provider
+    # @param method [Symbol] The iCalendar METHOD used to generate the content
     # @return [String, nil] The cache key or nil if caching is disabled
-    def cache_key_for(provider)
+    def cache_key_for(provider, method = :publish)
       return nil unless caching_enabled?
 
       attributes_hash = Digest::MD5.hexdigest(
@@ -167,7 +249,19 @@ module CalInvite
           notes,
           multi_day_sessions,
           all_day,
-          provider
+          organizer,
+          uid,
+          sequence,
+          geo,
+          reminders,
+          busy,
+          visibility,
+          rrule,
+          calendar_name,
+          importance,
+          allow_counter,
+          provider,
+          method
         ].map(&:to_s).join('|')
       )
 

data/lib/cal_invite/ical_timezone.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'tzinfo'
+require 'date'
+
+# lib/cal_invite/ical_timezone.rb
+module CalInvite
+  # Builds RFC 5545 VTIMEZONE components and converts UTC times to local wall-clock
+  # time for a given IANA/Olson timezone identifier, using TZInfo (already pulled in
+  # transitively via activesupport).
+  #
+  # Both entry points fail soft: if `tzid` isn't a TZInfo-recognized identifier (e.g.
+  # a raw UTC offset string like "+01:00", or 'UTC' itself), they return nil so
+  # callers can fall back to their previous behavior instead of raising.
+  #
+  # @api private
+  module IcalTimezone
+    module_function
+
+    # Converts a UTC time to local wall-clock time for the given timezone.
+    #
+    # @param tzid [String] An IANA timezone identifier, e.g. "America/New_York"
+    # @param utc_time [Time] The time to convert (interpreted as UTC)
+    # @return [Time, nil] The local wall-clock time, or nil if tzid is unrecognized
+    def local_time(tzid, utc_time)
+      return nil if tzid.nil? || tzid.to_s.strip.empty? || tzid.to_s.upcase == 'UTC'
+
+      TZInfo::Timezone.get(tzid.to_s).to_local(utc_time.utc)
+    rescue TZInfo::InvalidTimezoneIdentifier
+      nil
+    end
+
+    # Builds a complete VTIMEZONE component (STANDARD/DAYLIGHT observances with
+    # RRULEs derived from the timezone's actual transition rules) for the given
+    # timezone identifier.
+    #
+    # @param tzid [String] An IANA timezone identifier, e.g. "America/New_York"
+    # @return [Array<String>, nil] iCalendar lines for the VTIMEZONE component, or
+    #   nil if tzid is unrecognized, is UTC, or the component can't be built
+    def vtimezone_lines(tzid)
+      return nil if tzid.nil? || tzid.to_s.strip.empty? || tzid.to_s.upcase == 'UTC'
+
+      tz = TZInfo::Timezone.get(tzid.to_s)
+      current = tz.period_for(Time.now.utc)
+
+      if current.dst?
+        dst_period = current
+        std_period = period_before(tz, dst_period)
+      else
+        std_period = current
+        dst_period = period_after(tz, std_period)
+        dst_period = nil unless dst_period&.dst?
+      end
+
+      lines = ["BEGIN:VTIMEZONE", "TZID:#{tzid}"]
+
+      if std_period && dst_period
+        lines.concat(observance_lines('STANDARD', dst_period, std_period))
+        lines.concat(observance_lines('DAYLIGHT', std_period, dst_period))
+      else
+        lines.concat(fixed_observance_lines(std_period || dst_period || current))
+      end
+
+      lines << "END:VTIMEZONE"
+      lines
+    rescue StandardError
+      # Never let an exotic/edge-case timezone break calendar generation —
+      # worst case the VEVENT ends up without a VTIMEZONE definition.
+      nil
+    end
+
+    # @api private
+    def period_before(tz, period)
+      return nil unless period.starts_at
+
+      tz.period_for(period.starts_at.to_time - 1)
+    end
+
+    # @api private
+    def period_after(tz, period)
+      return nil unless period&.ends_at
+
+      tz.period_for(period.ends_at.to_time)
+    end
+
+    # @api private
+    def observance_lines(kind, from_period, to_period)
+      transition_time = from_period.local_ends_at.to_time
+
+      [
+        "BEGIN:#{kind}",
+        "DTSTART:#{transition_time.strftime('%Y%m%dT%H%M%S')}",
+        "TZOFFSETFROM:#{format_offset(from_period.offset.observed_utc_offset)}",
+        "TZOFFSETTO:#{format_offset(to_period.offset.observed_utc_offset)}",
+        "TZNAME:#{to_period.offset.abbreviation}",
+        rrule_line(transition_time),
+        "END:#{kind}"
+      ]
+    end
+
+    # @api private
+    def fixed_observance_lines(period)
+      [
+        "BEGIN:STANDARD",
+        "DTSTART:16010101T000000",
+        "TZOFFSETFROM:#{format_offset(period.offset.observed_utc_offset)}",
+        "TZOFFSETTO:#{format_offset(period.offset.observed_utc_offset)}",
+        "TZNAME:#{period.offset.abbreviation}",
+        "END:STANDARD"
+      ]
+    end
+
+    # Derives a YEARLY RRULE (e.g. "2nd Sunday in March") from a transition date.
+    #
+    # @api private
+    def rrule_line(time)
+      wday_names = %w[SU MO TU WE TH FR SA]
+      days_in_month = Date.new(time.year, time.month, -1).day
+      nth = (time.day - 1) / 7 + 1
+      nth = -1 if time.day + 7 > days_in_month
+
+      "RRULE:FREQ=YEARLY;BYMONTH=#{time.month};BYDAY=#{nth}#{wday_names[time.wday]}"
+    end
+
+    # @api private
+    def format_offset(seconds)
+      sign = seconds.negative? ? '-' : '+'
+      abs = seconds.abs
+      format('%<sign>s%<hours>02d%<minutes>02d', sign: sign, hours: abs / 3600, minutes: (abs % 3600) / 60)
+    end
+  end
+end

data/lib/cal_invite/providers/base_provider.rb

@@ -6,13 +6,16 @@
 #
 # @abstract Subclass and override {#generate} to implement a calendar provider
 class BaseProvider
-  attr_reader :event
+  attr_reader :event, :method
 
   # Initialize a new calendar provider
   #
   # @param event [CalInvite::Event] The event to generate a calendar URL for
-  def initialize(event)
+  # @param method [Symbol] The iCalendar METHOD (:publish or :request). Only
+  #   meaningful to the ics-family providers; URL-based providers ignore it.
+  def initialize(event, method: :publish)
     @event = event
+    @method = method
   end
 
   # Generate a calendar URL or content for the event.
@@ -70,16 +73,197 @@ class BaseProvider
     params[:location] = url_encode(format_location) if format_location
 
     if event.show_attendees && event.attendees&.any?
-      params[:attendees] = event.attendees.join(',')
+      params[:attendees] = attendee_emails.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
+  # @return [Array<String, Hash>] The list of attendees (email strings or
+  #   { email:, name:, partstat: } hashes) or empty array if disabled/none present
   def attendees_list
     return [] unless event.show_attendees && event.attendees&.any?
     event.attendees
   end
+
+  # Plain email addresses for all attendees, regardless of whether they were
+  # given as strings or { email:, name:, partstat: } hashes.
+  # @return [Array<String>]
+  def attendee_emails
+    attendees_list.map { |attendee| attendee_email(attendee) }
+  end
+
+  # @param attendee [String, Hash] An attendee as given in Event#attendees
+  # @return [String] The attendee's email address
+  def attendee_email(attendee)
+    attendee.is_a?(Hash) ? attendee_hash_value(attendee, :email) : attendee.to_s
+  end
+
+  # Reads `key` from an attendee hash, trying both symbol and string keys.
+  # Unlike `attendee[:key] || attendee["key"]`, this doesn't misread an
+  # explicit `false` value (e.g. `rsvp: false`) as "not set".
+  #
+  # @param attendee [Hash] An attendee hash
+  # @param key [Symbol] The key to read
+  # @return [Object, nil]
+  def attendee_hash_value(attendee, key)
+    return nil unless attendee.is_a?(Hash)
+    return attendee[key] if attendee.key?(key)
+
+    attendee[key.to_s]
+  end
+
+  NO_RSVP_METHODS = %i[reply counter decline_counter].freeze
+
+  PARTSTAT_VALUES = {
+    accepted: "ACCEPTED",
+    declined: "DECLINED",
+    tentative: "TENTATIVE",
+    needs_action: "NEEDS-ACTION",
+    delegated: "DELEGATED"
+  }.freeze
+
+  # Formats a full ATTENDEE property line for iCalendar output.
+  #
+  # @param attendee [String, Hash] An email string, or a hash like
+  #   { email:, name:, partstat:, rsvp: } for a display name, specific RSVP
+  #   status, and/or an explicit RSVP override. `rsvp:` is rarely needed —
+  #   e.g. a "registration confirmed" invite where the recipient is already
+  #   `partstat: :accepted` and nothing is actually being requested, so
+  #   `rsvp: false` suppresses `RSVP=TRUE` even under `method: :request`.
+  # @return [String] The formatted ATTENDEE line
+  def attendee_line(attendee)
+    email = attendee_email(attendee)
+    name = attendee_hash_value(attendee, :name)
+    partstat_key = attendee_hash_value(attendee, :partstat)
+    rsvp_override = attendee_hash_value(attendee, :rsvp)
+
+    cn = name ? %(;CN="#{name}") : ""
+    partstat = PARTSTAT_VALUES[partstat_key&.to_sym] || "NEEDS-ACTION"
+    # REPLY/COUNTER/DECLINECOUNTER all flow attendee -> organizer; RSVP=TRUE
+    # ("please respond") only makes sense on an organizer -> attendee REQUEST.
+    rsvp_default = !NO_RSVP_METHODS.include?(method)
+    rsvp = (rsvp_override.nil? ? rsvp_default : rsvp_override) ? ";RSVP=TRUE" : ""
+
+    "ATTENDEE;CUTYPE=INDIVIDUAL;ROLE=REQ-PARTICIPANT;PARTSTAT=#{partstat}#{rsvp}#{cn}:mailto:#{email}"
+  end
+
+  # Format the ORGANIZER property for iCalendar output
+  # @return [String, nil] The formatted ORGANIZER line, or nil if no organizer is set
+  def organizer_line
+    return nil unless event.organizer && event.organizer[:email]
+
+    name = event.organizer[:name]
+    cn = name ? %(;CN="#{name}") : ""
+    "ORGANIZER#{cn}:mailto:#{event.organizer[:email]}"
+  end
+
+  # The value for the calendar-level METHOD property. RFC 5545 spells this
+  # method "DECLINECOUNTER" (one word) despite `:decline_counter` reading more
+  # naturally as a Ruby symbol.
+  # @return [String] e.g. "REQUEST", "DECLINECOUNTER"
+  def method_value
+    method == :decline_counter ? "DECLINECOUNTER" : method.to_s.upcase
+  end
+
+  # The STATUS property, driven by the iCalendar METHOD in use.
+  # @return [String] "STATUS:CANCELLED" for :cancel, "STATUS:CONFIRMED" otherwise
+  def status_line
+    method == :cancel ? "STATUS:CANCELLED" : "STATUS:CONFIRMED"
+  end
+
+  # Converts a time to local wall-clock time for the event's timezone, for use in
+  # a `DTSTART;TZID=...`/`DTEND;TZID=...` property. Falls back to the time as given
+  # (unconverted) when the timezone isn't a TZInfo-recognized identifier (e.g. 'UTC'
+  # or a raw offset string), matching each provider's prior behavior for those cases.
+  #
+  # @param time [Time] The time to convert (interpreted as UTC)
+  # @return [Time] The local wall-clock time
+  def local_wall_time(time)
+    CalInvite::IcalTimezone.local_time(event.timezone, time) || time
+  end
+
+  # Builds the VTIMEZONE component lines for the event's timezone, if applicable.
+  # @return [Array<String>, nil] iCalendar lines, or nil for UTC/unrecognized timezones
+  def vtimezone_lines
+    CalInvite::IcalTimezone.vtimezone_lines(event.timezone)
+  end
+
+  # Format the GEO property from Event#geo.
+  # @return [String, nil] The formatted GEO line, or nil if no geo is set
+  def geo_line
+    return nil unless event.geo
+
+    lat, lng = event.geo.is_a?(Hash) ? [event.geo[:lat] || event.geo["lat"], event.geo[:lng] || event.geo["lng"]] : event.geo
+    return nil unless lat && lng
+
+    "GEO:#{lat};#{lng}"
+  end
+
+  # The TRANSP property, from Event#busy (default true).
+  # @return [String] "TRANSP:OPAQUE" (busy) or "TRANSP:TRANSPARENT" (free)
+  def transp_line
+    event.busy == false ? "TRANSP:TRANSPARENT" : "TRANSP:OPAQUE"
+  end
+
+  # The CLASS property, from Event#visibility (default :public).
+  # @return [String] e.g. "CLASS:PUBLIC"
+  def class_line
+    "CLASS:#{(event.visibility || :public).to_s.upcase}"
+  end
+
+  # The RRULE property, from Event#rrule, if set.
+  # @return [String, nil] e.g. "RRULE:FREQ=WEEKLY;COUNT=5", or nil if no rrule is set
+  def rrule_line
+    return nil unless event.rrule
+
+    value = event.rrule.to_s
+    value.start_with?("RRULE:") ? value : "RRULE:#{value}"
+  end
+
+  # Builds VALARM sub-components from Event#reminders (minutes-before-start values).
+  # @return [Array<String>] iCalendar lines, one VALARM block per reminder, or [] if none
+  def valarm_lines
+    return [] unless event.reminders&.any?
+
+    event.reminders.flat_map do |minutes|
+      ["BEGIN:VALARM", "TRIGGER:-PT#{minutes.to_i}M", "ACTION:DISPLAY", "DESCRIPTION:Reminder", "END:VALARM"]
+    end
+  end
+
+  IMPORTANCE_VALUES = { low: ["9", "0"], normal: ["5", "1"], high: ["1", "2"] }.freeze
+
+  # Standard RFC 5545 PRIORITY plus Outlook's non-standard
+  # X-MICROSOFT-CDO-IMPORTANCE, from Event#importance (:low/:normal/:high). Safe
+  # to always include: RFC 5545 requires unrecognized X- properties be ignored
+  # by compliant parsers, so this has no effect outside Outlook.
+  # @return [Array<String>] 0, 1, or 2 lines
+  def importance_lines
+    values = IMPORTANCE_VALUES[event.importance&.to_sym]
+    return [] unless values
+
+    priority, importance = values
+    ["PRIORITY:#{priority}", "X-MICROSOFT-CDO-IMPORTANCE:#{importance}"]
+  end
+
+  # Outlook's non-standard X-MICROSOFT-CDO-BUSYSTATUS, mirroring Event#busy.
+  # Included alongside the standard TRANSP property since some Outlook versions
+  # honor this one more reliably.
+  # @return [String] e.g. "X-MICROSOFT-CDO-BUSYSTATUS:BUSY"
+  def busystatus_line
+    "X-MICROSOFT-CDO-BUSYSTATUS:#{event.busy == false ? "FREE" : "BUSY"}"
+  end
+
+  # Outlook's non-standard X-MICROSOFT-DISALLOW-COUNTER, from Event#allow_counter
+  # (default true). Set Event#allow_counter = false to hide Outlook's "Propose
+  # New Time" action — the practical lever for "prevent attendee-initiated
+  # reschedules" on Outlook specifically; other clients don't expose an
+  # equivalent control and ignore this property.
+  # @return [String, nil] "X-MICROSOFT-DISALLOW-COUNTER:TRUE", or nil if counters are allowed
+  def disallow_counter_line
+    return nil if event.allow_counter != false
+
+    "X-MICROSOFT-DISALLOW-COUNTER:TRUE"
+  end
 end

data/lib/cal_invite/providers/ical.rb

@@ -38,7 +38,8 @@ module CalInvite
           "VERSION:2.0",
           "PRODID:-//CalInvite//Ruby//EN",
           "CALSCALE:GREGORIAN",
-          "METHOD:PUBLISH",
+          "METHOD:#{method_value}",
+          (event.calendar_name ? "X-WR-CALNAME:#{escape_text(event.calendar_name)}" : nil),
           generate_timezone,
           generate_events,
           "END:VCALENDAR"
@@ -85,7 +86,7 @@ module CalInvite
         # Required fields
         lines.concat([
           "SUMMARY:#{escape_text(event.title)}",
-          "UID:#{generate_uid}",
+          "UID:#{event.uid}",
           "DTSTAMP:#{format_timestamp(Time.now.utc)}"
         ])
 
@@ -93,37 +94,34 @@ module CalInvite
         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
+        lines << geo_line if geo_line
+        lines << organizer_line if organizer_line
 
         # Attendees
-        if attendees = attendees_list
-          attendees.each do |attendee|
-            lines << "ATTENDEE;RSVP=TRUE:mailto:#{attendee}"
-          end
-        end
+        attendees_list.each { |attendee| lines << attendee_line(attendee) }
 
+        lines << rrule_line if rrule_line
+        lines << "SEQUENCE:#{event.sequence}"
+        lines << status_line
+        lines << transp_line
+        lines << busystatus_line
+        lines << class_line
+        lines.concat(importance_lines)
+        lines << disallow_counter_line if disallow_counter_line
+        lines.concat(valarm_lines)
         lines << "END:VEVENT"
         lines.join("\r\n")
       end
 
-      # Generates the timezone block (VTIMEZONE) for the calendar.
-      # Only included for non-all-day events.
+      # Generates the timezone block (VTIMEZONE) for the calendar, with real
+      # STANDARD/DAYLIGHT observances derived from the timezone's transition rules.
+      # Only included for non-all-day events with a recognized, non-UTC timezone.
       #
-      # @return [String, nil] The formatted timezone block, or nil for all-day events
+      # @return [String, nil] The formatted timezone block, or nil if not applicable
       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
 
-      # Generates a unique identifier for the calendar event.
-      # Format: timestamp-randomhex@cal-invite
-      #
-      # @return [String] The generated UID
-      def generate_uid
-        "#{Time.now.to_i}-#{SecureRandom.hex(8)}@cal-invite"
+        vtimezone_lines&.join("\r\n")
       end
 
       # Formats a time object as a date string in iCalendar format.
@@ -135,12 +133,13 @@ module CalInvite
       end
 
       # Formats a time object as a local time string in iCalendar format.
-      # Times are assumed to be in the correct timezone already.
+      # Converts from UTC to the event's timezone; times are expected to be in
+      # UTC already.
       #
       # @param time [Time] The time to format
       # @return [String] The formatted local time (YYYYMMDDTHHmmSS)
       def format_local_time(time)
-        time.strftime("%Y%m%dT%H%M%S")
+        local_wall_time(time).strftime("%Y%m%dT%H%M%S")
       end
 
       # Formats a time object as an UTC timestamp in iCalendar format.