mailkube-rails 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f536b33be8802fb5082f7ff0728c24cdd6e0b236a8b1f1f9be280458a33ea7c9
+  data.tar.gz: a644b374eae8bccaa8efd2ab896ee3adec93e57a46857533ae66c7f20e32dcd5
+SHA512:
+  metadata.gz: dcf1c48032b57f0646d8ffb76cf3d4442176af146a8a2bcb54012dec515ccd36adc1365ead40bd48eceddab10816a14180c1274e9d75ec04feb791ad6502f1a6
+  data.tar.gz: a100a9dc37811df1eb70c9f42a5e15c70437a1a79f9f235f427e8e0a03b75adc46274b85f0aee49bdecf6d84c04c27f0ce0ff8104aef69705479e8af0be2a231

data/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or Derivative
+          Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Mailtactic, Corp.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/NOTICE

@@ -0,0 +1,11 @@
+mailkube-rails
+Copyright 2026 Mailtactic, Corp.
+
+This product is licensed under the Apache License, Version 2.0 (the "License");
+you may not use this product except in compliance with the License. You may
+obtain a copy of the License at:
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+"mailkube" is a trademark of Mailtactic, Corp. Use of the name is governed by
+Section 6 (Trademarks) of the License.

data/README.md

@@ -0,0 +1,198 @@
+# mailkube-rails
+
+[![CI](https://github.com/mailkube/mailkube-rails/actions/workflows/ci.yml/badge.svg)](https://github.com/mailkube/mailkube-rails/actions/workflows/ci.yml)
+[![Gem](https://img.shields.io/gem/v/mailkube-rails)](https://rubygems.org/gems/mailkube-rails)
+[![License: Apache 2.0](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](LICENSE)
+[![Code of Conduct](https://img.shields.io/badge/Contributor%20Covenant-2.1-purple.svg)](CODE_OF_CONDUCT.md)
+
+ActionMailer delivery method for mailkube.
+
+Send mail through mailkube using ActionMailer exactly as you already do, and receive webhooks as
+`ActiveSupport::Notifications`. This gem is a thin adapter over the
+[`mailkube`](https://rubygems.org/gems/mailkube) gem: the API, retries,
+errors and signature verification all live there.
+
+Requires Ruby 3.4+ and Rails 7.2.3+.
+
+## Install
+
+```ruby
+# Gemfile
+gem "mailkube-rails"
+```
+
+Then point ActionMailer at it:
+
+```ruby
+# config/environments/production.rb
+config.action_mailer.delivery_method = :mailkube
+config.action_mailer.mailkube_settings = {
+  api_key: ENV.fetch("MAILKUBE_API_KEY")
+}
+```
+
+That is the whole setup. Everything else on this page is optional.
+
+## Sending
+
+Nothing about your application changes. Mailers, `deliver_now`, `deliver_later`, attachments,
+`ActionMailer::Base.deliveries` in tests: all of it works as it already did.
+
+```ruby
+class OrderMailer < ApplicationMailer
+  def shipped(order)
+    mail(to: order.customer_email, subject: "Your order shipped")
+  end
+end
+
+OrderMailer.shipped(order).deliver_later
+```
+
+### What is mapped
+
+The sender, recipients (including blind copies), subject, both bodies, attachments and your custom
+headers. Anything ActionMailer's message can express, this delivery method passes through.
+
+Send-time features the SDK offers but `Mail::Message` has no slot for — tags, topics, templates,
+scheduling, idempotency keys — are reached by using the SDK directly:
+
+```ruby
+Mailkube.new.emails.send(
+  from: "Acme <hello@yourdomain.com>",
+  to: "customer@example.com",
+  subject: "Hello world",
+  html: "<p>It works!</p>",
+  tags: [Mailkube::Tag.new(name: "campaign", value: "spring")]
+)
+```
+
+> **Inline images degrade to ordinary attachments.** The API's attachment model carries a filename,
+> content and content type, with no content id, so a `cid:` reference has nothing to resolve
+> against. This is a capability of the platform rather than of this gem.
+
+## Configuration
+
+Two homes, and they do not overlap, so there is nothing to resolve between them.
+
+| Setting | Where | Environment fallback | Default |
+|---|---|---|---|
+| API key | `config.action_mailer.mailkube_settings[:api_key]` | `MAILKUBE_API_KEY` | required |
+| Base URL | `config.action_mailer.mailkube_settings[:base_url]` | `MAILKUBE_BASE_URL` | the SDK's |
+| Timeout | `config.action_mailer.mailkube_settings[:timeout]` | | the SDK's |
+| Webhook secret | `config.mailkube.webhook_secret` | | required for webhooks |
+| Webhook tolerance | `config.mailkube.webhook_tolerance` | | the SDK's |
+
+An unset setting is **omitted** rather than passed along as nil, so the SDK's own environment
+resolution still applies. That is why the API key can come from `MAILKUBE_API_KEY`
+alone with no Rails configuration at all.
+
+### Two accounts, two mailers
+
+ActionMailer resolves the delivery method per message, so overriding the settings on one mailer
+gives it its own client:
+
+```ruby
+class MarketingMailer < ApplicationMailer
+  self.mailkube_settings = { api_key: ENV.fetch("MARKETING_API_KEY") }
+end
+```
+
+## Errors
+
+A failed delivery raises `Mailkube::Rails::DeliveryError`, with the SDK's own exception preserved as
+`cause`.
+
+```ruby
+class OrderMailer < ApplicationMailer
+  retry_on Mailkube::Rails::DeliveryError, wait: :polynomially_longer, attempts: 5
+end
+```
+
+The class this gem owns is what you name, deliberately: naming an SDK class would tie your retry
+policy to the SDK's exception hierarchy, and it would break the day that hierarchy was reorganized.
+For the detail — which error, which status, whether it is safe to retry — read `cause`, where the
+SDK defines the categories once:
+
+```ruby
+rescue Mailkube::Rails::DeliveryError => e
+  Rails.logger.warn(e.cause.error_name)   # e.g. "quota_exceeded", with status_code and request_id
+end
+```
+
+`config.action_mailer.raise_delivery_errors = false` still swallows failures exactly as it does for
+any other delivery method.
+
+## Webhooks
+
+You write the route. A mountable engine would force a path on your application and drag generator
+machinery along for one endpoint, so this gem ships the controller and lets you mount it where you
+want:
+
+```ruby
+# config/initializers/mailkube.rb
+Rails.application.config.mailkube.webhook_secret = ENV.fetch("MAILKUBE_WEBHOOK_SECRET")
+```
+
+```ruby
+# config/routes.rb
+require "mailkube/rails/webhooks_controller"
+
+Rails.application.routes.draw do
+  post "/webhooks/mailkube",
+       to: Mailkube::Rails::WebhooksController.action(:create)
+end
+```
+
+The `require` is needed and the `.action(:create)` form is deliberate: a gem's `lib/` is on the load
+path but is not an autoload path, so the `"controller#action"` string form would name a constant
+Zeitwerk has never been told about.
+
+Deliveries are verified against the **raw** request body and published as one notification:
+
+```ruby
+# config/initializers/mailkube.rb
+ActiveSupport::Notifications.subscribe("webhook.mailkube") do |*, payload|
+  event = payload[:event]
+
+  case event
+  when Mailkube::Events::EmailDeliveredEvent then Rails.logger.info("delivered #{event.data.email_id}")
+  when Mailkube::Events::EmailBouncedEvent   then Suppression.add(event.data.email_id)
+  end
+end
+```
+
+One notification rather than one per webhook type, so an event this SDK release does not model still
+reaches your subscriber with its payload intact instead of being dropped.
+
+Subscribers run **inside the request**, and the endpoint answers as soon as they return. Enqueue
+anything slow, or delivery latency becomes retries.
+
+The endpoint answers `204` on success, `400` when verification fails, and `500` when no secret is
+configured — the last so that the platform keeps retrying rather than discarding deliveries while
+your configuration is broken. CSRF is skipped on this controller because a machine-to-machine POST
+cannot present a token; the signature is what authenticates the request, and it is strictly
+stronger. Any middleware that decodes and re-encodes the request body breaks verification: it no
+longer covers the bytes that were signed.
+
+## Extending this gem
+
+Before adding a setting, a mapped field, or another entry point, read
+[`.rules/INTEGRATION_CONTRACT.md`](.rules/INTEGRATION_CONTRACT.md) (what every mailkube framework
+integration does identically) and [`.rules/RAILS_INTEGRATION.md`](.rules/RAILS_INTEGRATION.md)
+(how those rules land here). Both carry a checklist.
+
+The short version: the capability has to exist in the SDK first, inputs are mapped in `payload.rb`
+and never at a call site, and configuration goes through `config.rb`.
+
+This gem ships no `examples/` directory, deliberately: every entry point it exposes needs a host
+Rails application before it can run. This README is the wiring documentation, and the spec suite is
+what keeps it honest.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for the development setup and the quality gates every change
+must pass. Security issues: see [SECURITY.md](SECURITY.md).
+
+## License
+
+[Apache-2.0](LICENSE) © 2026 Mailtactic, Corp.

data/lib/mailkube/rails/config.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Mailkube
+  module Rails
+    # The one place this gem turns Rails settings into SDK constructor arguments.
+    #
+    # Everything that reaches the SDK goes through {build_client}: the delivery method, the webhook
+    # endpoint, and anything added later. Two call sites building their own client is how one of
+    # them ends up on a different base URL, or without the User-Agent suffix, and the difference
+    # shows up as a support question rather than as a failing test.
+    #
+    # ## Two homes, and no precedence rules
+    #
+    # Settings live in the two places Rails already puts these kinds of settings, and they do not
+    # overlap, so there is nothing to resolve between them:
+    #
+    # - `config.action_mailer.mailkube_settings` — the delivery credentials. This hash is
+    #   what `add_delivery_method` creates, and ActionMailer hands it to the delivery method for
+    #   every message, so it is the idiomatic home and needs no invention.
+    # - `config.mailkube` — the webhook secret and freshness window, on the
+    #   `ActiveSupport::OrderedOptions` the Railtie installs. These are not delivery settings and
+    #   putting them under `action_mailer` would misfile them.
+    module Config
+      # SDK constructor keywords, mapped to the settings key that answers each.
+      #
+      # One list, so a setting cannot be readable in the delivery method and quietly ignored in
+      # a startup check. Adding an SDK keyword is a row here and nothing else.
+      CLIENT_KEYS = { api_key: :api_key, base_url: :base_url, timeout: :timeout }.freeze
+
+      # Build an SDK client from a delivery-method settings hash.
+      #
+      # @param settings [Hash{Symbol => Object}, nil] the `mailkube_settings` hash.
+      # @return [Mailkube::Client] the client, carrying this gem's User-Agent suffix.
+      # @raise [Mailkube::ConfigurationError] when no API key is available anywhere.
+      def self.build_client(settings)
+        # Splatted as keywords: a setting this gem did not resolve is simply not passed, which is
+        # what leaves the SDK's own default and its environment fallback in charge. Passing an
+        # explicit nil would suppress that fallback while looking like configuration.
+        Mailkube::Client.new(**client_kwargs(settings), user_agent_suffix: user_agent_suffix)
+      end
+
+      # Resolve the SDK keywords that are actually set, dropping the rest.
+      #
+      # @param settings [Hash{Symbol => Object}, nil] the `mailkube_settings` hash.
+      # @return [Hash{Symbol => Object}] the keywords to pass to the SDK.
+      def self.client_kwargs(settings)
+        given = settings || {}
+        kwargs = {} #: Hash[Symbol, untyped]
+        CLIENT_KEYS.each do |keyword, key|
+          value = given[key]
+          # An empty string is treated as unset. It is what an unset `ENV["..."]` interpolated
+          # into an initializer produces, and passing it through would defeat the SDK's fallback
+          # while looking like a configured value.
+          next if value.nil? || value == ""
+
+          kwargs[keyword] = value
+        end
+        kwargs
+      end
+
+      # This gem's own `name/version` token for the SDK's User-Agent.
+      #
+      # Read from {VERSION} rather than written here. A literal would be a second source of truth
+      # that the release process does not update, so it would go stale on the first release and
+      # stay wrong for every one after it. The SDK's own token stays leading, so the result is
+      # `mailkube/1.1.0 mailkube-rails/0.1.0`.
+      #
+      # @return [String] the suffix token.
+      def self.user_agent_suffix = "mailkube-rails/#{VERSION}"
+
+      # The webhook signing secret, or nil when none is configured.
+      #
+      # @param app_config [Object] an object responding to `mailkube`, normally `::Rails.application.config`.
+      # @return [String, nil] the secret, or nil.
+      def self.webhook_secret(app_config)
+        value = options(app_config).webhook_secret
+        value.is_a?(String) && !value.empty? ? value : nil
+      end
+
+      # The signature freshness tolerance, or nil to accept the SDK's documented default.
+      #
+      # @param app_config [Object] an object responding to `mailkube`.
+      # @return [Integer, nil] the window in seconds, or nil.
+      def self.webhook_tolerance(app_config)
+        value = options(app_config).webhook_tolerance
+        value.nil? ? nil : Integer(value)
+      end
+
+      # The gem's own options block, tolerating an application that never set one.
+      #
+      # `ActiveSupport::OrderedOptions` answers nil for any unset key, so this returns an empty one
+      # rather than nil and every reader above stays a single expression.
+      #
+      # @param app_config [Object] an object responding to `mailkube`.
+      # @return [ActiveSupport::OrderedOptions] the options block.
+      def self.options(app_config)
+        app_config.mailkube || ActiveSupport::OrderedOptions.new
+      end
+    end
+  end
+end

data/lib/mailkube/rails/delivery_method.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Mailkube
+  module Rails
+    # The ActionMailer delivery method: the outbound entry point, and error translation.
+    #
+    # ## The protocol this implements
+    #
+    # `Mail` instantiates a delivery method **once per message**, with one positional settings
+    # hash (`mail/message.rb`: `lookup_delivery_method(method).new(settings)`), then calls
+    # `deliver!(mail)`. Two consequences shape this class:
+    #
+    # - `settings` must be readable back off the instance. `Mail::Message#deliver!` evaluates
+    #   `delivery_method.settings[:return_response]`, so a delivery method whose `settings` is nil
+    #   raises there rather than delivering. It is a real requirement, not a convention.
+    # - The instance is per-message and short-lived, so the SDK client is memoized on it and that
+    #   is the whole lifecycle. There is deliberately no open/close pair: the SDK client is frozen
+    #   after construction and holds no pool to release, so a lifecycle module here would be
+    #   ceremony modelled on a protocol Rails does not have.
+    class DeliveryMethod
+      # @return [Hash{Symbol => Object}] the settings ActionMailer built this instance with.
+      attr_reader :settings
+
+      # @param settings [Hash{Symbol => Object}, nil] the `mailkube_settings` hash.
+      def initialize(settings = {})
+        @settings = settings || {}
+      end
+
+      # Deliver one message.
+      #
+      # @param message [Mail::Message] the message to send.
+      # @return [Mailkube::Email] the SDK's accepted-send result.
+      # @raise [DeliveryError] when the SDK reports any failure.
+      def deliver!(message)
+        fields = Payload.build(message)
+        # The three required keywords are named rather than left inside the splat. Steep cannot
+        # prove a Hash carries them, so a bare `**fields` would report them missing — and silencing
+        # that would silence the one check worth having here, which is that this gem still calls
+        # the SDK the way the SDK declares. A renamed keyword has to be a red build, not a
+        # production TypeError inside somebody's mailer.
+        client.emails.send(from: fields[:from], to: fields[:to], subject: fields[:subject],
+                           **fields.except(:from, :to, :subject))
+      rescue Mailkube::Error => e
+        # Translated at the boundary, with the SDK error kept as `cause` so nothing is lost. See
+        # DeliveryError for why this matters even though `do_delivery` already rescues broadly.
+        raise DeliveryError, e.message
+      end
+
+      # The SDK client for this delivery, built once.
+      #
+      # Lazy rather than built in the constructor: ActionMailer instantiates a delivery method
+      # while wrapping a message even when the message is never delivered — `Mail::TestMailer`
+      # substitution, `deliver_later` handing off to a job, an interceptor that aborts — and a
+      # missing API key must not raise on any of those paths.
+      #
+      # @return [Mailkube::Client] the client.
+      def client = @client ||= Config.build_client(@settings)
+    end
+  end
+end

data/lib/mailkube/rails/errors.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Mailkube
+  module Rails
+    # Raised when a delivery fails, wrapping the SDK error that caused it.
+    #
+    # **One class, and deliberately no subclasses.** Re-encoding the SDK's status taxonomy here
+    # would mean deciding what an HTTP 429 means, which the contract puts in the SDK's repository.
+    # The SDK's own exception is preserved as `cause`, so a caller that wants the category rescues
+    # it there, where the categories are defined once.
+    #
+    # ## Why translate at all
+    #
+    # Not for silent failure: `Mail::Message#do_delivery` rescues `StandardError` gated on
+    # `raise_delivery_errors`, so *any* exception class is already swallowed when an application
+    # asks for that. The reason is `deliver_later`. A queued delivery runs inside
+    # `ActionMailer::MailDeliveryJob`, and an application's `retry_on` / `discard_on` has to name a
+    # class. Naming an SDK class would make that application's retry policy break the day the SDK
+    # reorganized its hierarchy; naming this one means the SDK's taxonomy can change without it
+    # being a breaking change for consumers.
+    #
+    # This is the contract's "translate SDK errors into the framework's own error type" clause, in
+    # the one form Rails allows: ActionMailer ships no delivery-error class to translate into, so
+    # this gem defines the type consumers name.
+    #
+    #     class OrderMailer < ApplicationMailer
+    #       retry_on Mailkube::Rails::DeliveryError, wait: :polynomially_longer
+    #     end
+    class DeliveryError < StandardError; end
+  end
+end

data/lib/mailkube/rails/payload.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Mailkube
+  module Rails
+    # The one place a `Mail::Message` becomes SDK send arguments.
+    #
+    # Every entry point calls {build}; nothing else maps a message. A gem with two entry points and
+    # two mappings has two behaviours, and only one of them is the one the tests cover.
+    #
+    # Scope is deliberately what ActionMailer's message type natively expresses: sender,
+    # recipients, subject, both bodies, attachments and custom headers. Tags, topics, templates,
+    # scheduling and idempotency keys are SDK features with no `Mail::Message` slot, so inventing a
+    # side channel for them here would create a second surface to document and test. Reach them by
+    # calling the SDK directly; the README says so.
+    module Payload
+      # Header names ActionMailer derives from the message itself.
+      #
+      # These are re-created by the API from the structured fields this mapping already sends, so
+      # forwarding them as "custom" headers would contradict what the API builds. `content-type` is
+      # the one that matters: it describes a MIME document that is never transmitted, because this
+      # gem hands over fields rather than a rendered message.
+      RESERVED_HEADERS = %w[
+        bcc cc content-transfer-encoding content-type date from
+        message-id mime-version reply-to subject to
+      ].freeze
+
+      # Convert a message into the keyword arguments for `client.emails.send`.
+      #
+      # @param message [Mail::Message] the message ActionMailer built.
+      # @return [Hash{Symbol => Object}] the SDK send keywords.
+      def self.build(message)
+        {
+          from: addresses(message, :from).first,
+          to: addresses(message, :to),
+          subject: message.subject.to_s,
+          html: body_for(message, "text/html"),
+          text: body_for(message, "text/plain"),
+          cc: presence(addresses(message, :cc)),
+          bcc: presence(addresses(message, :bcc)),
+          reply_to: presence(addresses(message, :reply_to)),
+          headers: presence(custom_headers(message)),
+          attachments: presence(attachments(message))
+        }.compact
+      end
+
+      # Render one address field as RFC strings, keeping display names.
+      #
+      # **Read through `message[field]`, not through `message.to_addrs`.** The `*_addrs` readers
+      # return BARE addresses, so a display name is already gone by the time this sees them and no
+      # amount of re-parsing brings it back. `Mail::Field#addrs` returns the parsed address objects,
+      # and `.format` renders each one as the application wrote it.
+      #
+      # `*_addrs` is also incomplete: `from_addrs`, `to_addrs`, `cc_addrs` and `bcc_addrs` exist but
+      # there is no `reply_to_addrs`, so that one reaches `method_missing` and raises. Going through
+      # the field object treats all five identically and cannot develop that asymmetry.
+      #
+      # @param message [Mail::Message] the message.
+      # @param field [Symbol] the header field name.
+      # @return [Array<String>] the formatted addresses, empty when the field is absent.
+      def self.addresses(message, field)
+        header = message[field]
+        return [] if header.nil?
+
+        # The annotation is what makes this checkable. `header` is untyped (the framework side is
+        # deliberately shallow in sig/vendor/), so without it the element type erases to `bot` and
+        # Steep rejects `&:format` while RuboCop insists on it — the two gates deadlock. Naming the
+        # type resolves both, and it is the one place this gem asserts what `Mail` hands back.
+        addrs = header.addrs #: Array[::Mail::Address]
+        addrs.map(&:format)
+      end
+
+      # Extract one body part as decoded text.
+      #
+      # `.decoded`, never `.raw_source`: a quoted-printable or base64 body would otherwise ship its
+      # transfer encoding to the API verbatim, and the recipient would read `=3D` where an equals
+      # sign belongs.
+      #
+      # @param message [Mail::Message] the message.
+      # @param mime_type [String] the part's MIME type.
+      # @return [String, nil] the decoded body, or nil when the message has no such part.
+      def self.body_for(message, mime_type)
+        part = part_for(message, mime_type)
+        return nil if part.nil?
+
+        # `.decoded` undoes the transfer encoding but hands back ASCII-8BIT bytes, with the part's
+        # charset recorded separately. Passing those to JSON either raises on invalid byte sequences
+        # or ships mojibake, so the bytes are reunited with their declared charset here. `charset`
+        # can be absent on a bare message, and UTF-8 is the only sane assumption when it is.
+        presence(transcode(part.body.decoded, part.charset))
+      end
+
+      # Reinterpret decoded bytes in the charset the part declared.
+      #
+      # @param body [String] the decoded bytes.
+      # @param charset [String, nil] the part's declared charset.
+      # @return [String] the body as UTF-8 text.
+      def self.transcode(body, charset)
+        body.dup.force_encoding(charset || "UTF-8").encode("UTF-8")
+      rescue ArgumentError, EncodingError
+        # An unknown or lying charset must not stop the send. The bytes go out as they arrived,
+        # which is what any non-transcoding mapping would have done anyway.
+        body
+      end
+
+      # Find the part carrying one MIME type, or nil.
+      #
+      # Split out of {body_for} so the branch has somewhere to return `untyped` from: written
+      # inline, the `if`/`elsif` has no `else` arm and Steep infers `bot` for the result, making the
+      # decode below unreachable in its eyes.
+      #
+      # @param message [Mail::Message] the message.
+      # @param mime_type [String] the part's MIME type.
+      # @return [Object, nil] the matching part, or nil.
+      def self.part_for(message, mime_type)
+        return message.all_parts.find { |part| part.mime_type == mime_type && !part.attachment? } if message.multipart?
+        return message if message.mime_type == mime_type
+        return message if mime_type == "text/plain" && message.mime_type.nil?
+
+        nil
+      end
+
+      # Convert the message's attachments into SDK attachments.
+      #
+      # `.body.decoded` hands over the original bytes; the SDK base64-encodes them for the wire.
+      # Encoding here would send them twice over.
+      #
+      # @param message [Mail::Message] the message.
+      # @return [Array<Mailkube::Attachment>] the attachments.
+      def self.attachments(message)
+        message.attachments.map do |attachment|
+          Mailkube::Attachment.new(
+            filename: attachment.filename.to_s,
+            content: attachment.body.decoded,
+            content_type: attachment.mime_type
+          )
+        end
+      end
+
+      # Collect the headers the application set itself.
+      #
+      # @param message [Mail::Message] the message.
+      # @return [Hash{String => String}] the custom headers.
+      def self.custom_headers(message)
+        headers = {} #: Hash[String, String]
+        message.header.fields.each do |field|
+          next if RESERVED_HEADERS.include?(field.name.to_s.downcase)
+
+          headers[field.name.to_s] = field.value.to_s
+        end
+        headers
+      end
+
+      # Treat an empty string, array or hash as absent.
+      #
+      # An unset field is **omitted** from the send rather than passed as an empty value: the SDK
+      # drops nils before serializing, so this is what keeps an empty `cc` off the wire instead of
+      # sending `"cc": []`.
+      #
+      # @param value [Object, nil] the mapped value.
+      # @return [Object, nil] the value, or nil when it is empty.
+      def self.presence(value)
+        return nil if value.nil?
+        return nil if value.respond_to?(:empty?) && value.empty?
+
+        value
+      end
+    end
+  end
+end

data/lib/mailkube/rails/railtie.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "rails/railtie"
+
+module Mailkube
+  module Rails
+    # Registers the delivery method, and the gem's own options block, at boot.
+    #
+    # Note `::Rails::Railtie`, fully qualified. Inside this namespace the bare constant
+    # `Rails` is Mailkube::Rails, so `Rails::Railtie` would be a NameError at load. Every
+    # reference to the framework in this gem is written this way.
+    class Railtie < ::Rails::Railtie
+      # The gem's own settings block, so `config.mailkube.webhook_secret = ...` works in an
+      # initializer. `OrderedOptions` answers nil for anything unset, which is what lets
+      # {Config} read a key an application never assigned.
+      config.mailkube = ActiveSupport::OrderedOptions.new
+
+      # `before: "action_mailer.set_configs"` is load-bearing, not tidiness.
+      #
+      # `add_delivery_method` is what DEFINES the `mailkube_settings` class attribute
+      # (`action_mailer/delivery_methods.rb`: `class_attribute :"#{symbol}_settings"`). Rails then
+      # applies everything under `config.action_mailer` by calling those writers, with a bare
+      # `options.each { |k, v| send("#{k}=", v) }` at the end of `action_mailer.set_configs`.
+      #
+      # Register after that and an application setting `config.action_mailer.mailkube_settings`
+      # gets `NoMethodError: undefined method 'mailkube_settings='` at boot, which reads as a
+      # typo in their own config rather than as an ordering bug in this gem. `spec/naming_spec.rb`
+      # pins the declaration.
+      #
+      # The `on_load` hook is what defers the work until ActionMailer is actually loaded: naming
+      # the constant directly here would force it, and an application that does not use
+      # ActionMailer would pay for it at every boot.
+      initializer "mailkube-rails.add_delivery_method", before: "action_mailer.set_configs" do
+        ActiveSupport.on_load(:action_mailer) do
+          # steep:ignore:start
+          # `self` inside this block is `ActionMailer::Base`, which the framework substitutes at
+          # load time. No signature can express that, and modelling ActionMailer::Base in
+          # sig/vendor/ purely to satisfy one call would be a large stub for no checking value.
+          add_delivery_method :mailkube, Mailkube::Rails::DeliveryMethod
+          # steep:ignore:end
+        end
+      end
+    end
+  end
+end

data/lib/mailkube/rails/version.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Mailkube
+  module Rails
+    # This gem's version, and the only place it is written.
+    #
+    # The gemspec reads it, and so does the User-Agent suffix, so a release cannot report one
+    # version to RubyGems and a different one to the API. It stays at 0.0.0 in the repository:
+    # semantic-release rewrites this line in the release runner and never commits it back. See
+    # `.rules/RELEASE.md`.
+    VERSION = "1.0.0"
+  end
+end

data/lib/mailkube/rails/webhooks_controller.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "action_controller"
+
+require_relative "config"
+
+module Mailkube
+  module Rails
+    # The inbound entry point: verify a delivery, then publish it.
+    #
+    # This file is **not** required by `lib/mailkube/rails.rb`. It is reached through the route an
+    # application writes, so a worker that only sends mail never loads ActionController.
+    #
+    # ## No engine, deliberately
+    #
+    # A mountable engine would force a path on every host application and drag `isolate_namespace`
+    # plus generator machinery along for one endpoint. Consumers write two lines instead, which
+    # also means they choose the path, the constraints and the middleware:
+    #
+    #     require "mailkube/rails/webhooks_controller"
+    #     post "/webhooks/mailkube", to: Mailkube::Rails::WebhooksController.action(:create)
+    #
+    # The `.action(:create)` form rather than the `"controller#action"` string: a gem's `lib/` is
+    # on `$LOAD_PATH` but is not an autoload path, so the string form would resolve to a constant
+    # Zeitwerk has never been told about and raise at the first request. The explicit `require` is
+    # what makes the constant exist, and is the reason this file can stay off the boot path.
+    #
+    # This differs from the Laravel integration, where a package registering a route is completely
+    # idiomatic and the route is registered for you behind an off-by-default setting.
+    #
+    # ## It contains no cryptography
+    #
+    # Verification is the SDK's, in one call. This class adapts Rails' request object to it and
+    # publishes the result. See `.rules/INTEGRATION_CONTRACT.md`.
+    class WebhooksController < ::ActionController::Base
+      # The notification this controller publishes on a verified delivery.
+      NOTIFICATION = "webhook.mailkube"
+
+      # A webhook POST is machine-to-machine and cannot carry a CSRF token, so the check is skipped
+      # rather than left to reject every delivery. The signature is what authenticates the request,
+      # and it is strictly stronger: CSRF protection proves a browser session, while the HMAC
+      # proves the sender holds the endpoint secret.
+      skip_forgery_protection
+
+      # Receive one webhook delivery.
+      #
+      # Answers 204 on success, 400 when verification fails, and 500 when no secret is configured.
+      #
+      # @return [void]
+      def create
+        secret = Config.webhook_secret(::Rails.application.config)
+        # 500, not 4xx. The sender is behaving correctly and the fault is entirely local, so this
+        # must read as an outage: the platform then keeps retrying, and the deliveries that arrive
+        # while the secret is missing are not silently discarded.
+        return head(:internal_server_error) if secret.nil?
+
+        event = Mailkube::Webhooks.verify(
+          payload: request.raw_post, headers: header_hash, secret: secret, **tolerance_argument
+        )
+        ActiveSupport::Notifications.instrument(NOTIFICATION, event: event)
+        head :no_content
+      rescue Mailkube::SignatureVerificationError, Mailkube::Error
+        # A malformed or unverifiable delivery is the sender's problem and a retry cannot fix it,
+        # so it is refused rather than retried. The reason is deliberately not reported: an
+        # endpoint that distinguishes "bad signature" from "stale timestamp" is an oracle.
+        head :bad_request
+      end
+
+      private
+
+      # The freshness window, as a splattable hash, or empty to accept the SDK's default.
+      #
+      # Only the optional argument travels in a splat: the three required ones are named at the
+      # call site so Steep checks them against the SDK's own signature. Omitted rather than passed
+      # as nil, because nil would be a value the SDK has to interpret rather than an absent one.
+      #
+      # @return [Hash{Symbol => Integer}] `{tolerance: n}`, or empty.
+      def tolerance_argument
+        tolerance = Config.webhook_tolerance(::Rails.application.config)
+        tolerance.nil? ? {} : { tolerance: tolerance }
+      end
+
+      # Convert the Rack environment into the plain Hash the SDK reads headers from.
+      #
+      # **`request.headers` cannot be passed through**, which is worth stating because it is the
+      # obvious thing to write and it fails twice over. `ActionDispatch::Http::Headers` includes
+      # `Enumerable` and nothing else, so it has no `transform_keys` and the SDK's normalization
+      # raises `NoMethodError` on it. And its `each` delegates to the Rack environment, so
+      # converting it to a Hash yields `HTTP_X_WEBHOOK_ID` rather than `X-Webhook-Id` — which
+      # downcases to something the SDK's lookup will never match, turning every delivery into a
+      # signature failure with no clue as to why.
+      #
+      # The conversion is generic rather than a list of the three headers the SDK reads today.
+      # Naming them would put a copy of the signature scheme's header set in this repository, and
+      # the copy would silently stop working the day the scheme grows a fourth.
+      #
+      # @return [Hash{String => String}] the request headers, in `x-webhook-id` form.
+      def header_hash
+        headers = {} #: Hash[String, String]
+        request.env.each do |name, value|
+          next unless name.is_a?(String) && name.start_with?("HTTP_") && value.is_a?(String)
+
+          headers[name.delete_prefix("HTTP_").downcase.tr("_", "-")] = value
+        end
+        headers
+      end
+    end
+  end
+end

data/lib/mailkube/rails.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "mailkube"
+
+require_relative "rails/version"
+require_relative "rails/errors"
+require_relative "rails/config"
+require_relative "rails/payload"
+require_relative "rails/delivery_method"
+require_relative "rails/railtie"
+
+module Mailkube
+  # ActionMailer delivery for mailkube, and an inbound webhook endpoint.
+  #
+  # This module is a **thin adapter**. The wire format, authentication, retry policy, error
+  # taxonomy and webhook signature scheme all belong to the `mailkube` gem; nothing here
+  # re-implements any of them. See `.rules/INTEGRATION_CONTRACT.md`.
+  #
+  # Requiring this file loads the delivery half only. {WebhooksController} is deliberately NOT
+  # required here: it subclasses `ActionController::Base`, and a worker process that only sends
+  # mail should not be made to load ActionController. Applications that receive webhooks reach it
+  # through the route they write, which autoloads it.
+  #
+  # ## The naming trap
+  #
+  # Inside this namespace the bare constant `Rails` resolves to **this module**, not to the
+  # framework. Every reference to the framework is therefore written `::Rails`, fully
+  # qualified. Ruby resolves the wrong one silently and the result is a `NoMethodError` a long way
+  # from the cause, so this is the most likely first bug in any change here. `spec/naming_spec.rb`
+  # pins it.
+  module Rails
+  end
+end

data/sig/mailkube/rails.rbs

@@ -0,0 +1,63 @@
+# Signatures for this gem's public surface.
+#
+# These are checked two ways, and both are needed:
+#   `rbs validate` proves the signatures are internally coherent (every type they name exists).
+#   `steep check`  proves the implementation matches them.
+# `rbs validate` alone never loads `lib/`, so it would happily pass a `sig/` describing methods
+# that do not exist, which is the exact drift this directory is here to prevent.
+#
+# The framework's own types are declared in `sig/vendor/`, which is NOT shipped in the gem. See
+# the gemspec, and `.rules/RAILS_INTEGRATION.md`.
+module Mailkube
+  module Rails
+    VERSION: String
+
+    class DeliveryError < StandardError
+    end
+
+    module Config
+      CLIENT_KEYS: Hash[Symbol, Symbol]
+
+      def self.build_client: (Hash[Symbol, untyped]?) -> Mailkube::Client
+      def self.client_kwargs: (Hash[Symbol, untyped]?) -> Hash[Symbol, untyped]
+      def self.user_agent_suffix: () -> String
+      def self.webhook_secret: (untyped) -> String?
+      def self.webhook_tolerance: (untyped) -> Integer?
+      def self.options: (untyped) -> untyped
+    end
+
+    module Payload
+      RESERVED_HEADERS: Array[String]
+
+      def self.build: (untyped) -> Hash[Symbol, untyped]
+      def self.addresses: (untyped, Symbol) -> Array[String]
+      def self.body_for: (untyped, String) -> String?
+      def self.transcode: (String, String?) -> String
+      def self.part_for: (untyped, String) -> untyped
+      def self.attachments: (untyped) -> Array[Mailkube::Attachment]
+      def self.custom_headers: (untyped) -> Hash[String, String]
+      def self.presence: (untyped) -> untyped
+    end
+
+    class DeliveryMethod
+      @client: Mailkube::Client?
+
+      attr_reader settings: Hash[Symbol, untyped]
+
+      def initialize: (?Hash[Symbol, untyped]?) -> void
+      def deliver!: (untyped) -> Mailkube::Email
+      def client: () -> Mailkube::Client
+    end
+
+    class Railtie < ::Rails::Railtie
+    end
+
+    class WebhooksController < ::ActionController::Base
+      NOTIFICATION: String
+
+      def create: () -> void
+      def tolerance_argument: () -> Hash[Symbol, Integer]
+      def header_hash: () -> Hash[String, String]
+    end
+  end
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: mailkube-rails
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Mailtactic, Corp.
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionmailer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.2.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.2.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+- !ruby/object:Gem::Dependency
+  name: mailkube
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.2.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.2.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9'
+description: 'ActionMailer delivery method for mailkube. A thin adapter over the mailkube
+  gem: deliver through ActionMailer, receive webhooks as ActiveSupport notifications.'
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- NOTICE
+- README.md
+- lib/mailkube/rails.rb
+- lib/mailkube/rails/config.rb
+- lib/mailkube/rails/delivery_method.rb
+- lib/mailkube/rails/errors.rb
+- lib/mailkube/rails/payload.rb
+- lib/mailkube/rails/railtie.rb
+- lib/mailkube/rails/version.rb
+- lib/mailkube/rails/webhooks_controller.rb
+- sig/mailkube/rails.rbs
+homepage: https://github.com/mailkube/mailkube-rails
+licenses:
+- Apache-2.0
+metadata:
+  source_code_uri: https://github.com/mailkube/mailkube-rails
+  changelog_uri: https://github.com/mailkube/mailkube-rails/releases
+  bug_tracker_uri: https://github.com/mailkube/mailkube-rails/issues
+  documentation_uri: https://rubydoc.info/gems/mailkube-rails
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: ActionMailer delivery method for mailkube.
+test_files: []