actionmailer 3.2.9 → 6.1.7.6

data/lib/action_mailer/collector.rb

@@ -1,8 +1,10 @@
-require 'abstract_controller/collector'
-require 'active_support/core_ext/hash/reverse_merge'
-require 'active_support/core_ext/array/extract_options'
+# frozen_string_literal: true
 
-module ActionMailer #:nodoc:
+require "abstract_controller/collector"
+require "active_support/core_ext/hash/reverse_merge"
+require "active_support/core_ext/array/extract_options"
+
+module ActionMailer
   class Collector
     include AbstractController::Collector
     attr_reader :responses
@@ -15,13 +17,13 @@ module ActionMailer #:nodoc:
 
     def any(*args, &block)
       options = args.extract_options!
-      raise "You have to supply at least one format" if args.empty?
+      raise ArgumentError, "You have to supply at least one format" if args.empty?
       args.each { |type| send(type, options.dup, &block) }
     end
     alias :all :any
 
-    def custom(mime, options={})
-      options.reverse_merge!(:content_type => mime.to_s)
+    def custom(mime, options = {})
+      options.reverse_merge!(content_type: mime.to_s)
       @context.formats = [mime.to_sym]
       options[:body] = block_given? ? yield : @default_render.call
       @responses << options

data/lib/action_mailer/delivery_job.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "active_job"
+
+module ActionMailer
+  # The <tt>ActionMailer::DeliveryJob</tt> class is used when you
+  # want to send emails outside of the request-response cycle.
+  #
+  # Exceptions are rescued and handled by the mailer class.
+  class DeliveryJob < ActiveJob::Base # :nodoc:
+    queue_as { ActionMailer::Base.deliver_later_queue_name }
+
+    rescue_from StandardError, with: :handle_exception_with_mailer_class
+
+    before_perform do
+      ActiveSupport::Deprecation.warn <<~MSG.squish
+        Sending mail with DeliveryJob and Parameterized::DeliveryJob
+        is deprecated and will be removed in Rails 7.0.
+        Please use MailDeliveryJob instead.
+      MSG
+    end
+
+    def perform(mailer, mail_method, delivery_method, *args) #:nodoc:
+      mailer.constantize.public_send(mail_method, *args).send(delivery_method)
+    end
+    ruby2_keywords(:perform) if respond_to?(:ruby2_keywords, true)
+
+    private
+      # "Deserialize" the mailer class name by hand in case another argument
+      # (like a Global ID reference) raised DeserializationError.
+      def mailer_class
+        if mailer = Array(@serialized_arguments).first || Array(arguments).first
+          mailer.constantize
+        end
+      end
+
+      def handle_exception_with_mailer_class(exception)
+        if klass = mailer_class
+          klass.handle_exception exception
+        else
+          raise exception
+        end
+      end
+  end
+end

data/lib/action_mailer/delivery_methods.rb

@@ -1,72 +1,68 @@
-require 'tmpdir'
+# frozen_string_literal: true
+
+require "tmpdir"
 
 module ActionMailer
-  # This module handles everything related to mail delivery, from registering new
-  # delivery methods to configuring the mail object to be sent.
+  # This module handles everything related to mail delivery, from registering
+  # new delivery methods to configuring the mail object to be sent.
   module DeliveryMethods
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :delivery_methods, :delivery_method
-
       # Do not make this inheritable, because we always want it to propagate
-      cattr_accessor :raise_delivery_errors
-      self.raise_delivery_errors = true
-
-      cattr_accessor :perform_deliveries
-      self.perform_deliveries = true
+      cattr_accessor :raise_delivery_errors, default: true
+      cattr_accessor :perform_deliveries, default: true
+      cattr_accessor :deliver_later_queue_name, default: :mailers
 
-      self.delivery_methods = {}.freeze
-      self.delivery_method  = :smtp
+      class_attribute :delivery_methods, default: {}.freeze
+      class_attribute :delivery_method, default: :smtp
 
       add_delivery_method :smtp, Mail::SMTP,
-        :address              => "localhost",
-        :port                 => 25,
-        :domain               => 'localhost.localdomain',
-        :user_name            => nil,
-        :password             => nil,
-        :authentication       => nil,
-        :enable_starttls_auto => true
+        address:              "localhost",
+        port:                 25,
+        domain:               "localhost.localdomain",
+        user_name:            nil,
+        password:             nil,
+        authentication:       nil,
+        enable_starttls_auto: true
 
       add_delivery_method :file, Mail::FileDelivery,
-        :location => defined?(Rails.root) ? "#{Rails.root}/tmp/mails" : "#{Dir.tmpdir}/mails"
+        location: defined?(Rails.root) ? "#{Rails.root}/tmp/mails" : "#{Dir.tmpdir}/mails"
 
       add_delivery_method :sendmail, Mail::Sendmail,
-        :location   => '/usr/sbin/sendmail',
-        :arguments  => '-i -t'
+        location:  "/usr/sbin/sendmail",
+        arguments: "-i"
 
       add_delivery_method :test, Mail::TestMailer
     end
 
+    # Helpers for creating and wrapping delivery behavior, used by DeliveryMethods.
     module ClassMethods
       # Provides a list of emails that have been delivered by Mail::TestMailer
-      delegate :deliveries, :deliveries=, :to => Mail::TestMailer
+      delegate :deliveries, :deliveries=, to: Mail::TestMailer
 
-      # Adds a new delivery method through the given class using the given symbol
-      # as alias and the default options supplied:
-      #
-      # Example:
+      # Adds a new delivery method through the given class using the given
+      # symbol as alias and the default options supplied.
       #
       #   add_delivery_method :sendmail, Mail::Sendmail,
-      #     :location   => '/usr/sbin/sendmail',
-      #     :arguments  => '-i -t'
-      #
-      def add_delivery_method(symbol, klass, default_options={})
+      #     location:  '/usr/sbin/sendmail',
+      #     arguments: '-i'
+      def add_delivery_method(symbol, klass, default_options = {})
         class_attribute(:"#{symbol}_settings") unless respond_to?(:"#{symbol}_settings")
-        send(:"#{symbol}_settings=", default_options)
+        public_send(:"#{symbol}_settings=", default_options)
         self.delivery_methods = delivery_methods.merge(symbol.to_sym => klass).freeze
       end
 
-      def wrap_delivery_behavior(mail, method=nil) #:nodoc:
-        method ||= self.delivery_method
+      def wrap_delivery_behavior(mail, method = nil, options = nil) # :nodoc:
+        method ||= delivery_method
         mail.delivery_handler = self
 
         case method
         when NilClass
           raise "Delivery method cannot be nil"
         when Symbol
-          if klass = delivery_methods[method.to_sym]
-            mail.delivery_method(klass, send(:"#{method}_settings"))
+          if klass = delivery_methods[method]
+            mail.delivery_method(klass, (send(:"#{method}_settings") || {}).merge(options || {}))
           else
             raise "Invalid delivery method #{method.inspect}"
           end
@@ -79,7 +75,7 @@ module ActionMailer
       end
     end
 
-    def wrap_delivery_behavior!(*args) #:nodoc:
+    def wrap_delivery_behavior!(*args) # :nodoc:
       self.class.wrap_delivery_behavior(message, *args)
     end
   end

data/lib/action_mailer/gem_version.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActionMailer
+  # Returns the version of the currently loaded Action Mailer as a <tt>Gem::Version</tt>.
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 6
+    MINOR = 1
+    TINY  = 7
+    PRE   = "6"
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end

data/lib/action_mailer/inline_preview_interceptor.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "base64"
+
+module ActionMailer
+  # Implements a mailer preview interceptor that converts image tag src attributes
+  # that use inline cid: style URLs to data: style URLs so that they are visible
+  # when previewing an HTML email in a web browser.
+  #
+  # This interceptor is enabled by default. To disable it, delete it from the
+  # <tt>ActionMailer::Base.preview_interceptors</tt> array:
+  #
+  #   ActionMailer::Base.preview_interceptors.delete(ActionMailer::InlinePreviewInterceptor)
+  #
+  class InlinePreviewInterceptor
+    PATTERN = /src=(?:"cid:[^"]+"|'cid:[^']+')/i
+
+    include Base64
+
+    def self.previewing_email(message) #:nodoc:
+      new(message).transform!
+    end
+
+    def initialize(message) #:nodoc:
+      @message = message
+    end
+
+    def transform! #:nodoc:
+      return message if html_part.blank?
+
+      html_part.body = html_part.decoded.gsub(PATTERN) do |match|
+        if part = find_part(match[9..-2])
+          %[src="#{data_url(part)}"]
+        else
+          match
+        end
+      end
+
+      message
+    end
+
+    private
+      attr_reader :message
+
+      def html_part
+        @html_part ||= message.html_part
+      end
+
+      def data_url(part)
+        "data:#{part.mime_type};base64,#{strict_encode64(part.body.raw_source)}"
+      end
+
+      def find_part(cid)
+        message.all_parts.find { |p| p.attachment? && p.cid == cid }
+      end
+  end
+end

data/lib/action_mailer/log_subscriber.rb

@@ -1,22 +1,39 @@
-require 'active_support/core_ext/array/wrap'
+# frozen_string_literal: true
+
+require "active_support/log_subscriber"
 
 module ActionMailer
+  # Implements the ActiveSupport::LogSubscriber for logging notifications when
+  # email is delivered or received.
   class LogSubscriber < ActiveSupport::LogSubscriber
+    # An email was delivered.
     def deliver(event)
-      recipients = Array.wrap(event.payload[:to]).join(', ')
-      info("\nSent mail to #{recipients} (%1.fms)" % event.duration)
-      debug(event.payload[:mail])
+      info do
+        perform_deliveries = event.payload[:perform_deliveries]
+        if perform_deliveries
+          "Delivered mail #{event.payload[:message_id]} (#{event.duration.round(1)}ms)"
+        else
+          "Skipped delivery of mail #{event.payload[:message_id]} as `perform_deliveries` is false"
+        end
+      end
+
+      debug { event.payload[:mail] }
     end
 
-    def receive(event)
-      info("\nReceived mail (%.1fms)" % event.duration)
-      debug(event.payload[:mail])
+    # An email was generated.
+    def process(event)
+      debug do
+        mailer = event.payload[:mailer]
+        action = event.payload[:action]
+        "#{mailer}##{action}: processed outbound mail in #{event.duration.round(1)}ms"
+      end
     end
 
+    # Use the logger configured for ActionMailer::Base.
     def logger
       ActionMailer::Base.logger
     end
   end
 end
 
-ActionMailer::LogSubscriber.attach_to :action_mailer
+ActionMailer::LogSubscriber.attach_to :action_mailer

data/lib/action_mailer/mail_delivery_job.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "active_job"
+
+module ActionMailer
+  # The <tt>ActionMailer::MailDeliveryJob</tt> class is used when you
+  # want to send emails outside of the request-response cycle. It supports
+  # sending either parameterized or normal mail.
+  #
+  # Exceptions are rescued and handled by the mailer class.
+  class MailDeliveryJob < ActiveJob::Base # :nodoc:
+    queue_as { ActionMailer::Base.deliver_later_queue_name }
+
+    rescue_from StandardError, with: :handle_exception_with_mailer_class
+
+    def perform(mailer, mail_method, delivery_method, args:, kwargs: nil, params: nil)
+      mailer_class = params ? mailer.constantize.with(params) : mailer.constantize
+      message = if kwargs
+        mailer_class.public_send(mail_method, *args, **kwargs)
+      else
+        mailer_class.public_send(mail_method, *args)
+      end
+      message.send(delivery_method)
+    end
+
+    private
+      # "Deserialize" the mailer class name by hand in case another argument
+      # (like a Global ID reference) raised DeserializationError.
+      def mailer_class
+        if mailer = Array(@serialized_arguments).first || Array(arguments).first
+          mailer.constantize
+        end
+      end
+
+      def handle_exception_with_mailer_class(exception)
+        if klass = mailer_class
+          klass.handle_exception exception
+        else
+          raise exception
+        end
+      end
+  end
+end

data/lib/action_mailer/mail_helper.rb

@@ -1,15 +1,30 @@
+# frozen_string_literal: true
+
 module ActionMailer
+  # Provides helper methods for ActionMailer::Base that can be used for easily
+  # formatting messages, accessing mailer or message instances, and the
+  # attachments list.
   module MailHelper
-    # Uses Text::Format to take the text and format it, indented two spaces for
-    # each line, and wrapped at 72 columns.
+    # Take the text and format it, indented two spaces for each line, and
+    # wrapped at 72 columns:
+    #
+    #   text = <<-TEXT
+    #     This is
+    #     the      paragraph.
+    #
+    #     * item1 * item2
+    #   TEXT
+    #
+    #   block_format text
+    #   # => "  This is the paragraph.\n\n  * item1\n  * item2\n"
     def block_format(text)
-      formatted = text.split(/\n\r\n/).collect { |paragraph|
+      formatted = text.split(/\n\r?\n/).collect { |paragraph|
         format_paragraph(paragraph)
-      }.join("\n")
+      }.join("\n\n")
 
       # Make list points stand on their own line
-      formatted.gsub!(/[ ]*([*]+) ([^*]*)/) { |s| "  #{$1} #{$2.strip}\n" }
-      formatted.gsub!(/[ ]*([#]+) ([^#]*)/) { |s| "  #{$1} #{$2.strip}\n" }
+      formatted.gsub!(/[ ]*([*]+) ([^*]*)/) { "  #{$1} #{$2.strip}\n" }
+      formatted.gsub!(/[ ]*([#]+) ([^#]*)/) { "  #{$1} #{$2.strip}\n" }
 
       formatted
     end
@@ -26,14 +41,14 @@ module ActionMailer
 
     # Access the message attachments list.
     def attachments
-      @_message.attachments
+      mailer.attachments
     end
 
     # Returns +text+ wrapped at +len+ columns and indented +indent+ spaces.
+    # By default column length +len+ equals 72 characters and indent
+    # +indent+ equal two spaces.
     #
-    # === Examples
-    #
-    #   my_text = "Here is a sample text with more than 40 characters"
+    #   my_text = 'Here is a sample text with more than 40 characters'
     #
     #   format_paragraph(my_text, 25, 4)
     #   # => "    Here is a sample text with\n    more than 40 characters"
@@ -41,15 +56,16 @@ module ActionMailer
       sentences = [[]]
 
       text.split.each do |word|
-        if (sentences.last + [word]).join(' ').length > len
+        if sentences.first.present? && (sentences.last + [word]).join(" ").length > len
           sentences << [word]
         else
           sentences.last << word
         end
       end
 
-      sentences.map { |sentence|
-        "#{" " * indent}#{sentence.join(' ')}"
+      indentation = " " * indent
+      sentences.map! { |sentence|
+        "#{indentation}#{sentence.join(' ')}"
       }.join "\n"
     end
   end

data/lib/action_mailer/mail_with_error_handling.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+begin
+  require "mail"
+rescue LoadError => error
+  if error.message.match?(/net\/smtp/)
+    $stderr.puts "You don't have net-smtp installed in your application. Please add it to your Gemfile and run bundle install"
+    raise
+  end
+end

data/lib/action_mailer/message_delivery.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module ActionMailer
+  # The <tt>ActionMailer::MessageDelivery</tt> class is used by
+  # ActionMailer::Base when creating a new mailer.
+  # <tt>MessageDelivery</tt> is a wrapper (+Delegator+ subclass) around a lazy
+  # created <tt>Mail::Message</tt>. You can get direct access to the
+  # <tt>Mail::Message</tt>, deliver the email or schedule the email to be sent
+  # through Active Job.
+  #
+  #   Notifier.welcome(User.first)               # an ActionMailer::MessageDelivery object
+  #   Notifier.welcome(User.first).deliver_now   # sends the email
+  #   Notifier.welcome(User.first).deliver_later # enqueue email delivery as a job through Active Job
+  #   Notifier.welcome(User.first).message       # a Mail::Message object
+  class MessageDelivery < Delegator
+    def initialize(mailer_class, action, *args) #:nodoc:
+      @mailer_class, @action, @args = mailer_class, action, args
+
+      # The mail is only processed if we try to call any methods on it.
+      # Typical usage will leave it unloaded and call deliver_later.
+      @processed_mailer = nil
+      @mail_message = nil
+    end
+    ruby2_keywords(:initialize) if respond_to?(:ruby2_keywords, true)
+
+    # Method calls are delegated to the Mail::Message that's ready to deliver.
+    def __getobj__ #:nodoc:
+      @mail_message ||= processed_mailer.message
+    end
+
+    # Unused except for delegator internals (dup, marshalling).
+    def __setobj__(mail_message) #:nodoc:
+      @mail_message = mail_message
+    end
+
+    # Returns the resulting Mail::Message
+    def message
+      __getobj__
+    end
+
+    # Was the delegate loaded, causing the mailer action to be processed?
+    def processed?
+      @processed_mailer || @mail_message
+    end
+
+    # Enqueues the email to be delivered through Active Job. When the
+    # job runs it will send the email using +deliver_now!+. That means
+    # that the message will be sent bypassing checking +perform_deliveries+
+    # and +raise_delivery_errors+, so use with caution.
+    #
+    #   Notifier.welcome(User.first).deliver_later!
+    #   Notifier.welcome(User.first).deliver_later!(wait: 1.hour)
+    #   Notifier.welcome(User.first).deliver_later!(wait_until: 10.hours.from_now)
+    #   Notifier.welcome(User.first).deliver_later!(priority: 10)
+    #
+    # Options:
+    #
+    # * <tt>:wait</tt> - Enqueue the email to be delivered with a delay
+    # * <tt>:wait_until</tt> - Enqueue the email to be delivered at (after) a specific date / time
+    # * <tt>:queue</tt> - Enqueue the email on the specified queue
+    # * <tt>:priority</tt> - Enqueues the email with the specified priority
+    #
+    # By default, the email will be enqueued using <tt>ActionMailer::DeliveryJob</tt>. Each
+    # <tt>ActionMailer::Base</tt> class can specify the job to use by setting the class variable
+    # +delivery_job+.
+    #
+    #   class AccountRegistrationMailer < ApplicationMailer
+    #     self.delivery_job = RegistrationDeliveryJob
+    #   end
+    def deliver_later!(options = {})
+      enqueue_delivery :deliver_now!, options
+    end
+
+    # Enqueues the email to be delivered through Active Job. When the
+    # job runs it will send the email using +deliver_now+.
+    #
+    #   Notifier.welcome(User.first).deliver_later
+    #   Notifier.welcome(User.first).deliver_later(wait: 1.hour)
+    #   Notifier.welcome(User.first).deliver_later(wait_until: 10.hours.from_now)
+    #   Notifier.welcome(User.first).deliver_later(priority: 10)
+    #
+    # Options:
+    #
+    # * <tt>:wait</tt> - Enqueue the email to be delivered with a delay.
+    # * <tt>:wait_until</tt> - Enqueue the email to be delivered at (after) a specific date / time.
+    # * <tt>:queue</tt> - Enqueue the email on the specified queue.
+    # * <tt>:priority</tt> - Enqueues the email with the specified priority
+    #
+    # By default, the email will be enqueued using <tt>ActionMailer::DeliveryJob</tt>. Each
+    # <tt>ActionMailer::Base</tt> class can specify the job to use by setting the class variable
+    # +delivery_job+.
+    #
+    #   class AccountRegistrationMailer < ApplicationMailer
+    #     self.delivery_job = RegistrationDeliveryJob
+    #   end
+    def deliver_later(options = {})
+      enqueue_delivery :deliver_now, options
+    end
+
+    # Delivers an email without checking +perform_deliveries+ and +raise_delivery_errors+,
+    # so use with caution.
+    #
+    #   Notifier.welcome(User.first).deliver_now!
+    #
+    def deliver_now!
+      processed_mailer.handle_exceptions do
+        message.deliver!
+      end
+    end
+
+    # Delivers an email:
+    #
+    #   Notifier.welcome(User.first).deliver_now
+    #
+    def deliver_now
+      processed_mailer.handle_exceptions do
+        message.deliver
+      end
+    end
+
+    private
+      # Returns the processed Mailer instance. We keep this instance
+      # on hand so we can delegate exception handling to it.
+      def processed_mailer
+        @processed_mailer ||= @mailer_class.new.tap do |mailer|
+          mailer.process @action, *@args
+        end
+      end
+
+      def enqueue_delivery(delivery_method, options = {})
+        if processed?
+          ::Kernel.raise "You've accessed the message before asking to " \
+            "deliver it later, so you may have made local changes that would " \
+            "be silently lost if we enqueued a job to deliver it. Why? Only " \
+            "the mailer method *arguments* are passed with the delivery job! " \
+            "Do not access the message in any way if you mean to deliver it " \
+            "later. Workarounds: 1. don't touch the message before calling " \
+            "#deliver_later, 2. only touch the message *within your mailer " \
+            "method*, or 3. use a custom Active Job instead of #deliver_later."
+        else
+          job = @mailer_class.delivery_job
+
+          if use_new_args?(job)
+            job.set(options).perform_later(
+              @mailer_class.name, @action.to_s, delivery_method.to_s, args: @args)
+          elsif job <= DeliveryJob
+            job.set(options).perform_later(
+              @mailer_class.name, @action.to_s, delivery_method.to_s, *@args)
+          else
+            ActiveSupport::Deprecation.warn(<<~EOM)
+              In Rails 7.0, Action Mailer will pass the mail arguments inside the `:args` keyword argument.
+              The `perform` method of the #{job} needs to change and forward the mail arguments
+              from the `args` keyword argument.
+
+              The `perform` method should now look like:
+
+              `def perform(mailer, mail_method, delivery, args:)`
+            EOM
+
+            job.set(options).perform_later(
+              @mailer_class.name, @action.to_s, delivery_method.to_s, *@args)
+          end
+        end
+      end
+
+      def use_new_args?(job)
+        parameters = job.public_instance_method(:perform).parameters
+
+        parameters.find do |key, name|
+          return true if key == :keyreq && name == :args
+
+          key == :keyrest and name != :**
+        end
+      end
+  end
+end