padrino-mailer 0.18.2 → 0.18.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac2d83b55958d57fb6cced02c2ec08e3613982594069bc9b08036bd95f02e63b
-  data.tar.gz: 0500d718cf0f13ca82fd90097cec7548eb4e824e0e72678bb1cffff87f947955
+  metadata.gz: b11b32ce2d59a91d317eaa40ad82491aad78b7717d269846ff009ff8b1faec13
+  data.tar.gz: 5bcc8d002ca343172c0706f834ecfc8d7e559d516c1a8fdab94c77d5c82519fa
 SHA512:
-  metadata.gz: ae82b89755b7e13c0c66b629ff060f3e24ea509fba47b0e9259ec8a637230021f109bdb8edb70b56f31c2cc8b54c09ad4185240f5f8cbcf0e3cbcf93d72bf713
-  data.tar.gz: 98d1b6fd13eb78d43fac67b5e1372ed01fe4bb6d5312b5fd73bdb0df0cf1ebaffd89ab44d22ab03fcdd9b3c1a4f25f685f0b1aacc618e5ca16c9fab13e8210aa
+  metadata.gz: e2999d5468663f308a0f3ec49ba3f53e793a8bd9f79e3dd741465c3ceedcad4cf94e0ef8906eba3d78a18c81387b7e5d70648eb8a396e08bc3d609e2fe6b782c
+  data.tar.gz: '01877f03e82419e0adc3f50e2c9ff719db6ea4d4f774714faae403a09f2f6a2cf2955dece2d2f415c9bdeceb3e32de21ef42e894cf042ef2f0f55dd50ed18ba1'

data/lib/padrino-mailer/ext.rb

@@ -9,16 +9,57 @@ module Mail # @private
     attr_reader :template_cache
     attr_accessor :mailer_name, :message_name
 
+    # The template cache of a message whose app doesn't reload templates. Templates given by name
+    # (a file or a named template) are compiled once for the class and shared by its messages;
+    # templates given as a string stay with the message, so they don't pile up.
+    class SharedTemplateCache < Sinatra::TemplateCache # @private
+      def initialize(owner)
+        super()
+        @owner = owner
+      end
+
+      def fetch(engine, data, *rest, &block)
+        return super unless data.is_a?(Symbol)
+
+        @shared ||= @owner.shared_template_cache
+        @shared.fetch(engine, data, *rest, &block)
+      end
+
+      # Message#to_yaml dumps every instance variable; keep the class's templates and lock out of it.
+      def encode_with(coder); end
+    end
+
+    # The cache a class's messages share. Messages are often delivered from several threads, and
+    # on JRuby writing to a Hash from two threads at once can raise, so it takes a lock. It compiles
+    # outside the lock, so two threads may compile one template; the first one stored is kept.
+    class LockedTemplateCache # @private
+      def initialize
+        @cache = {}
+        @lock = Mutex.new
+      end
+
+      def fetch(*key)
+        @lock.synchronize { return @cache[key] if @cache.key?(key) }
+        template = yield
+        @lock.synchronize { @cache.fetch(key) { @cache[key] = template } }
+      end
+    end
+
+    SHARED_TEMPLATE_CACHE_LOCK = Mutex.new # @private
+
+    def self.shared_template_cache # @private
+      SHARED_TEMPLATE_CACHE_LOCK.synchronize { @_shared_template_cache ||= LockedTemplateCache.new }
+    end
+
     def initialize_with_app(*args, &block)
-      @template_cache = Sinatra::TemplateCache.new
       # Check if we have an app passed into initialize
       if args[0].respond_to?(:views) && args[0].respond_to?(:reload_templates?)
         app                       = args.shift
         @_views                   = File.join(app.views, 'mailers')
-        settings.reload_templates = app.reload_templates?
+        settings.reload_templates = self.reload_templates = app.reload_templates?
       else
         @_views = File.expand_path('./mailers')
-        settings.reload_templates = true
+        settings.reload_templates = self.reload_templates = true
       end
 
       initialize_template_settings!
@@ -109,7 +150,7 @@ module Mail # @private
       part_block = params.delete(:part_block)
       new_part = Mail::Part.new(params)
       new_part.views(@_views)
-      new_part.settings.reload_templates = settings.reload_templates?
+      new_part.settings.reload_templates = new_part.reload_templates = reload_templates?
       new_part.instance_eval(&part_block) if part_block
       yield new_part if block_given?
       add_part(new_part)
@@ -151,6 +192,23 @@ module Mail # @private
       @_mailer_views = false
     end
 
+    ##
+    # Returns true if this message reads its templates again on every render, as its app's
+    # reload_templates setting said when the message was built.
+    #
+    def reload_templates?
+      @_reload_templates
+    end
+
+    ##
+    # Sets whether this message reads its templates again on every render. A message that does
+    # keeps every template to itself; one that doesn't shares the templates it renders by name.
+    #
+    def reload_templates=(value)
+      @_reload_templates = value
+      @template_cache = value ? Sinatra::TemplateCache.new : SharedTemplateCache.new(self.class)
+    end
+
     ##
     # Sets the local variables available within the message template.
     #
@@ -276,7 +334,7 @@ module Mail # @private
     #
     def render(engine = nil, data = nil, options = {}, locals = {}, &block)
       locals = @_locals || {} if !options[:locals] && locals.empty?
-      @template_cache.clear if settings.reload_templates?
+      @template_cache.clear if reload_templates?
 
       # render(nil, 'template', ...) as RenderHelpers#partial calls it: shift the arguments
       # the way Padrino::Rendering#render does, before defaulting to the message name.

data/test/helper.rb

@@ -2,6 +2,11 @@ ENV['RACK_ENV'] = 'test'
 PADRINO_ROOT = __dir__ unless defined? PADRINO_ROOT
 
 require 'minitest/autorun'
+begin
+  require 'minitest/mock'
+rescue LoadError
+  # minitest/mock is built-in for older minitest versions
+end
 require 'minitest/pride'
 require 'rack/test'
 require 'padrino-core'

data/test/test_email.rb

@@ -259,6 +259,84 @@ describe 'Email' do
       assert_equal 'B[beta hello]', @app.deliver(:beta, :boxed).body.to_s.strip
     end
 
+    it 'should compile a mailer template once for all its deliveries' do
+      mailer_app(mailer_views('site'))
+      @app.set :reload_templates, false
+      compiled = 0
+      engine = Tilt[:erb]
+      new_template = engine.method(:new)
+      engine.stub(:new, lambda { |*args, &block|
+        compiled += 1
+        new_template.call(*args, &block)
+      }) do
+        2.times { assert_equal 'alpha hello', @app.deliver(:alpha, :hello).body.to_s }
+      end
+      assert_equal 1, compiled
+    end
+
+    it 'should read an edited mailer template when templates reload' do
+      views = mailer_views('site')
+      mailer_app(views)
+      @app.set :reload_templates, false
+      assert_equal 'alpha hello', @app.deliver(:alpha, :hello).body.to_s
+      File.write(File.join(views, 'mailers', 'alpha', 'hello.erb'), 'alpha edited')
+      @app.set :reload_templates, true
+      assert_equal 'alpha edited', @app.deliver(:alpha, :hello).body.to_s
+    end
+
+    it 'should read an edited part template when templates reload' do
+      views = mailer_views('site')
+      mailer_app(views)
+      @app.set :reload_templates, true
+      assert_equal 'gamma plain', @app.deliver(:gamma, :hello).parts.first.body.to_s
+      File.write(File.join(views, 'mailers', 'gamma', 'hello.plain.erb'), 'gamma plain edited')
+      assert_equal 'gamma plain edited', @app.deliver(:gamma, :hello).parts.first.body.to_s
+    end
+
+    it 'should compile part templates once for all their deliveries' do
+      mailer_app(mailer_views('site'))
+      @app.set :reload_templates, false
+      compiled = 0
+      engine = Tilt[:erb]
+      new_template = engine.method(:new)
+      engine.stub(:new, lambda { |*args, &block|
+        compiled += 1
+        new_template.call(*args, &block)
+      }) do
+        2.times do
+          assert_equal(['gamma plain', 'gamma html'], @app.deliver(:gamma, :hello).parts.map { |part| part.body.to_s })
+        end
+      end
+      assert_equal 2, compiled
+    end
+
+    it 'should not dump the templates other messages share' do
+      mailer_app(mailer_views('site'))
+      @app.set :reload_templates, false
+      @app.deliver(:beta, :hello)
+      message = build_message(:alpha)
+      assert_equal 'alpha hello', message.send(:render, :hello)
+      yaml = message.to_yaml
+      refute_includes yaml, 'beta hello'
+      refute_includes yaml, 'Mutex'
+    end
+
+    it 'should keep the shared templates when a message of another app reloads them' do
+      views = mailer_views('site')
+      cached = mailer_app(views)
+      cached.set :reload_templates, false
+      reloading = mailer_app(views)
+      reloading.set :reload_templates, true
+      assert_equal 'alpha hello', cached.deliver(:alpha, :hello).body.to_s
+      File.write(File.join(views, 'mailers', 'alpha', 'hello.erb'), 'alpha edited')
+      @app = cached
+      waiting = build_message(:alpha)
+      @app = reloading
+      assert_equal 'alpha edited', build_message(:alpha).send(:render, :hello)
+      assert_equal 'alpha hello', waiting.send(:render, :hello)
+      assert_equal 'alpha hello', cached.deliver(:alpha, :hello).body.to_s
+    end
+
     MailerFormUser = Struct.new(:name) unless defined?(MailerFormUser)
 
     it 'should build forms with form_for in a mailer template' do

data/test/test_message.rb

@@ -212,4 +212,33 @@ describe 'Message' do
       end
     end
   end
+
+  describe 'the shared template cache' do
+    before { @cache = Mail::Message::LockedTemplateCache.new }
+
+    it 'should give threads that compile a template at the same time the one it keeps' do
+      threads = Array.new(2) do
+        Thread.new do
+          @cache.fetch(:erb, :same) do
+            sleep 0.05
+            Object.new
+          end
+        end
+      end
+      kept = threads.map(&:value)
+      assert_same kept[0], kept[1]
+      assert_same(kept[0], @cache.fetch(:erb, :same) { flunk 'compiled a stored template again' })
+    end
+
+    it 'should serve other templates while one compiles' do
+      release = Queue.new
+      slow = Thread.new { @cache.fetch(:erb, :slow) { release.pop && :slow } }
+      Thread.pass while slow.status == 'run'
+      fast = Thread.new { @cache.fetch(:erb, :fast) { :fast } }
+      assert_equal :fast, fast.join(2) && fast.value
+    ensure
+      release << true
+      assert_equal :slow, slow.value
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: padrino-mailer
 version: !ruby/object:Gem::Version
-  version: 0.18.2
+  version: 0.18.4
 platform: ruby
 authors:
 - Padrino Team
@@ -11,7 +11,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-11-01 00:00:00.000000000 Z
+date: 2026-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: padrino-core
@@ -19,14 +19,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.2
+        version: 0.18.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.18.2
+        version: 0.18.4
 - !ruby/object:Gem::Dependency
   name: mime-types
   requirement: !ruby/object:Gem::Requirement