letter_opener_web-redis 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 210afa6ebf7862a38c9b5fd79e6d53f5331dcc91bafed3d386ef24e8a2b4125c
+  data.tar.gz: 5d0b6bd37962133afd3efc1d42208c035df1fa41702ffbfae84f32a0db21b921
+SHA512:
+  metadata.gz: d1381185ae7a6dc594a0e3969c54ffab48386013c1ab5a2c4e0122fb876aeafd8011ffbc60e72d2240e86068affa2dd0f4b812e4bb4fbcec5ef7f07a35a42c60
+  data.tar.gz: cfd73ec500699cf764e2ac07881e1dc9b3def67717f62bfe0877db625e101a837eef4274352fe137fc8a3fc9a6c2d2e66d87363e7720fc9b36e7718eb3c9b408

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2025 Letter Opener Web Redis Contributors
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,68 @@
+# LetterOpenerWeb::Redis
+
+Redis storage backend for [letter_opener_web](https://github.com/fgrehm/letter_opener_web).
+
+This gem allows you to store email letters and attachments in Redis instead of the local filesystem, enabling multi-instance deployments and shared email viewing across application servers.
+
+## Installation
+
+Add these lines to your application's Gemfile:
+
+```ruby
+gem 'letter_opener_web'
+gem 'letter_opener_web-redis', require: 'letter_opener_web_redis'
+```
+
+## Configuration
+
+### 1. Configure Redis Connection
+
+Set up your Redis connection in your Rails configuration file (e.g., `config/environments/development.rb`):
+
+```ruby
+# Require the gem first
+require 'letter_opener_web_redis'
+
+LetterOpenerWeb.configure do |config|
+  # Use the Redis storage backend
+  config.letter_class = LetterOpenerWeb::RedisLetter
+
+  # Redis Configuration
+  config.redis_url = ENV.fetch('REDIS_URL', 'redis://localhost:6379/0')
+  config.redis_namespace = 'letter_opener' # optional, defaults to 'letter_opener'
+end
+```
+
+### 2. Configure ActionMailer
+
+Update your ActionMailer configuration to use the Redis delivery method:
+
+```ruby
+config.action_mailer.delivery_method = :letter_opener_web_redis
+```
+
+## Storage Structure
+
+Emails are stored in Redis with the following key structure:
+
+```
+{namespace}:letters:ids                          # Set of all letter IDs
+{namespace}:letter:{id}:metadata                 # JSON metadata (id, sent_at, attachments)
+{namespace}:letter:{id}:plain                    # Plain text HTML
+{namespace}:letter:{id}:rich                     # Rich HTML
+{namespace}:letter:{id}:attachment:{filename}    # Base64-encoded attachment content
+```
+
+Where `{namespace}` defaults to `letter_opener` but can be customized via configuration.
+
+## Memory Considerations
+
+Since Redis stores all data in memory, be mindful of:
+
+- **Email Size**: Large attachments will consume significant memory
+- **Retention**: Consider implementing TTL (time-to-live) for old emails
+- **Limits**: Monitor Redis memory usage and set appropriate limits
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/letter_opener_web/redis_delivery_method.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'letter_opener'
+
+module LetterOpenerWeb
+  class RedisDeliveryMethod < LetterOpener::DeliveryMethod
+    def deliver!(mail)
+      location = create_location
+      message = RedisMessage.new(mail, location: location)
+      message.render
+    end
+
+    private
+
+    def create_location
+      location = File.join(settings[:location], "#{Time.now.to_i}_#{SecureRandom.hex(16)}")
+      FileUtils.mkdir_p(location)
+      location
+    end
+  end
+end

data/lib/letter_opener_web/redis_letter.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require 'redis'
+require 'json'
+
+module LetterOpenerWeb
+  # Redis-based Letter implementation
+  #
+  # Stores and retrieves letters from Redis instead of the local filesystem.
+  # Letters are stored as Redis hashes with the following structure:
+  #   - letter:{id}:plain - Plain text HTML
+  #   - letter:{id}:rich - Rich HTML
+  #   - letter:{id}:metadata - JSON with id, sent_at, attachments
+  #   - letter:{id}:attachment:{filename} - Attachment content
+  #   - letters:ids - Set of all letter IDs
+  class RedisLetter
+    include LetterOpenerWeb::LetterInterface
+
+    def self.redis
+      @redis ||= Redis.new(
+        url: LetterOpenerWeb.config.redis_url,
+        timeout: 5
+      )
+    end
+
+    def self.key_prefix
+      namespace = LetterOpenerWeb.config.redis_namespace
+      namespace ? "#{namespace}:" : ''
+    end
+
+    def self.search
+      letter_ids = redis.smembers("#{key_prefix}letters:ids")
+
+      letters = letter_ids.map do |id|
+        metadata = redis.get("#{key_prefix}letter:#{id}:metadata")
+        next unless metadata
+
+        data = JSON.parse(metadata)
+        new(id: data['id'], sent_at: Time.parse(data['sent_at']))
+      end.compact
+
+      letters.sort_by(&:sent_at).reverse
+    end
+
+    def self.find(id)
+      new(id: id)
+    end
+
+    def self.destroy_all
+      # Get all letter IDs
+      letter_ids = redis.smembers("#{key_prefix}letters:ids")
+
+      # Delete all keys associated with each letter
+      letter_ids.each do |id|
+        keys = redis.keys("#{key_prefix}letter:#{id}:*")
+        redis.del(*keys) if keys.any?
+      end
+
+      # Clear the IDs set
+      redis.del("#{key_prefix}letters:ids")
+    end
+
+    def initialize(params)
+      @id = params.fetch(:id)
+      @sent_at = params[:sent_at] || Time.now
+    end
+
+    def headers
+      html = read_file('rich') if file_exists?('rich')
+      html ||= read_file('plain')
+
+      return 'UNABLE TO PARSE HEADERS' if html.blank?
+
+      match_data = html.match(%r{<body>\s*<div[^>]+id="container">\s*<div[^>]+id="message_headers">\s*(<dl>.+</dl>)}m)
+      return remove_attachments_link(match_data[1]).html_safe if match_data && match_data[1].present?
+
+      'UNABLE TO PARSE HEADERS'
+    end
+
+    def plain_text
+      @plain_text ||= adjust_link_targets(read_file('plain'))
+    end
+
+    def rich_text
+      @rich_text ||= adjust_link_targets(read_file('rich'))
+    end
+
+    def attachments
+      @attachments ||= begin
+        metadata = redis.get("#{key_prefix}letter:#{id}:metadata")
+        return {} unless metadata
+
+        data = JSON.parse(metadata)
+        data['attachments'] || {}
+      end
+    end
+
+    def delete
+      return unless valid?
+
+      keys = redis.keys("#{key_prefix}letter:#{id}:*")
+      redis.del(*keys) if keys.any?
+      redis.srem("#{key_prefix}letters:ids", id)
+    end
+
+    def valid?
+      file_exists?('rich') || file_exists?('plain')
+    end
+
+    def to_param
+      id
+    end
+
+    def default_style
+      file_exists?('rich') ? 'rich' : 'plain'
+    end
+
+    def send_attachment(controller, filename)
+      return unless attachments.key?(filename)
+
+      encoded = redis.get("#{key_prefix}letter:#{id}:attachment:#{filename}")
+      return unless encoded
+
+      content = Base64.strict_decode64(encoded)
+      controller.send_data(content, filename: filename, type: 'application/octet-stream', disposition: 'inline')
+    rescue ArgumentError
+      nil
+    end
+
+    private
+
+    def redis
+      self.class.redis
+    end
+
+    def key_prefix
+      self.class.key_prefix
+    end
+
+    def read_file(style)
+      redis.get("#{key_prefix}letter:#{id}:#{style}") || ''
+    end
+
+    def file_exists?(style)
+      redis.exists("#{key_prefix}letter:#{id}:#{style}") == 1
+    end
+
+    def remove_attachments_link(headers)
+      xml = REXML::Document.new(headers)
+      label_element = xml.root.elements.find { |e| e.get_text&.value&.match?(/attachments:/i) }
+
+      if label_element
+        xml.root.delete_element(label_element.next_element)
+        xml.root.delete_element(label_element)
+      end
+
+      xml.to_s
+    end
+
+    def adjust_link_targets(contents)
+      return contents if contents.blank?
+
+      contents.scan(%r{<a\s[^>]+>(?:.|\s)*?</a>}).each do |link|
+        fixed_link = fix_link_html(link)
+        xml = REXML::Document.new(fixed_link).root
+        next if xml.attributes['href'] =~ /(plain|rich).html/
+
+        xml.attributes['target'] = '_blank'
+        xml.add_text('') unless xml.text
+        contents.gsub!(link, xml.to_s)
+      end
+      contents
+    end
+
+    def fix_link_html(link_html)
+      link_html.dup.tap do |fixed_link|
+        fixed_link.gsub!('<br>', '<br/>')
+        fixed_link.scan(/<img(?:[^>]+?)>/).each do |img|
+          fixed_img = img.dup
+          fixed_img.gsub!(/>$/, '/>') unless img =~ %r{/>$}
+          fixed_link.gsub!(img, fixed_img)
+        end
+      end
+    end
+  end
+end

data/lib/letter_opener_web/redis_message.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'letter_opener'
+require 'json'
+require 'base64'
+
+module LetterOpenerWeb
+  # Extends LetterOpener::Message to store email content in Redis
+  #
+  # This class intercepts the message delivery and stores the generated
+  # HTML files and attachments in Redis instead of keeping them on local disk.
+  class RedisMessage < LetterOpener::Message
+    def render
+      # Call parent to generate the HTML files locally first
+      super
+
+      # Store in Redis
+      store_in_redis
+
+      # Clean up local files after storing
+      cleanup_local_files
+    end
+
+    private
+
+    attr_reader :location
+
+    def store_in_redis
+      store_html_files
+      store_attachments
+      store_metadata
+      register_letter_id
+    end
+
+    def store_html_files
+      %w[rich plain].each do |style|
+        file_path = "#{location}/#{style}.html"
+        next unless File.exist?(file_path)
+
+        content = File.read(file_path)
+        redis.set("#{key_prefix}letter:#{letter_id}:#{style}", content)
+      end
+    end
+
+    def store_attachments
+      attachments_dir = "#{location}/attachments"
+      return unless Dir.exist?(attachments_dir)
+
+      attachment_data = {}
+
+      Dir.glob("#{attachments_dir}/*").each do |file_path|
+        filename = File.basename(file_path)
+
+        # Store attachment content as base64
+        content = File.binread(file_path)
+        encoded = Base64.strict_encode64(content)
+
+        redis.set("#{key_prefix}letter:#{letter_id}:attachment:#{filename}", encoded)
+
+        # Track attachment in metadata
+        attachment_data[filename] = filename
+      end
+
+      @attachment_data = attachment_data
+    end
+
+    def store_metadata
+      metadata = {
+        id: letter_id,
+        sent_at: Time.now.iso8601,
+        attachments: @attachment_data || {}
+      }
+
+      redis.set("#{key_prefix}letter:#{letter_id}:metadata", metadata.to_json)
+    end
+
+    def register_letter_id
+      redis.sadd("#{key_prefix}letters:ids", letter_id)
+    end
+
+    def cleanup_local_files
+      FileUtils.rm_rf(location)
+    end
+
+    def letter_id
+      @letter_id ||= File.basename(location)
+    end
+
+    def redis
+      @redis ||= Redis.new(
+        url: LetterOpenerWeb.config.redis_url,
+        timeout: 5
+      )
+    end
+
+    def key_prefix
+      namespace = LetterOpenerWeb.config.redis_namespace
+      namespace ? "#{namespace}:" : ''
+    end
+  end
+end

data/lib/letter_opener_web_redis.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'letter_opener_web'
+require 'letter_opener_web/redis_letter'
+require 'letter_opener_web/redis_message'
+require 'letter_opener_web/redis_delivery_method'
+
+# Add Redis-specific configuration to LetterOpenerWeb::Config immediately
+LetterOpenerWeb::Config.class_eval do
+  attr_accessor :redis_url, :redis_namespace
+
+  # Set default Redis namespace
+  def redis_namespace
+    @redis_namespace ||= 'letter_opener'
+  end
+end
+
+module LetterOpenerWeb
+  module RedisStorage
+    class Railtie < Rails::Railtie
+      initializer 'letter_opener_web_redis.configure' do
+        # Register custom delivery method that uses RedisDeliveryMethod
+        ActionMailer::Base.add_delivery_method(
+          :letter_opener_web_redis,
+          LetterOpenerWeb::RedisDeliveryMethod,
+          location: Rails.root.join('tmp', 'letter_opener')
+        )
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: letter_opener_web-redis
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Adnan Ali
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-10-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: letter_opener_web
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Provides Redis-based storage for letter_opener_web, enabling multi-instance
+  deployments and shared email viewing across application servers.
+email:
+- adnan.ali@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/letter_opener_web/redis_delivery_method.rb
+- lib/letter_opener_web/redis_letter.rb
+- lib/letter_opener_web/redis_message.rb
+- lib/letter_opener_web_redis.rb
+homepage: https://github.com/WizaCo/letter_opener_web-redis
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: Redis storage backend for letter_opener_web
+test_files: []