actionmailer 3.0.4 → 7.1.6

data/lib/action_mailer/callbacks.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ActionMailer
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveSupport::Callbacks
+      define_callbacks :deliver, skip_after_callbacks_if_terminated: true
+    end
+
+    module ClassMethods
+      # Defines a callback that will get called right before the
+      # message is sent to the delivery method.
+      def before_deliver(*filters, &blk)
+        set_callback(:deliver, :before, *filters, &blk)
+      end
+
+      # Defines a callback that will get called right after the
+      # message's delivery method is finished.
+      def after_deliver(*filters, &blk)
+        set_callback(:deliver, :after, *filters, &blk)
+      end
+
+      # Defines a callback that will get called around the message's deliver method.
+      def around_deliver(*filters, &blk)
+        set_callback(:deliver, :around, *filters, &blk)
+      end
+    end
+  end
+end

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,16 +17,16 @@ 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)
-      @context.freeze_formats([mime.to_sym])
+    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
     end
   end
-end
+end

data/lib/action_mailer/delivery_methods.rb

@@ -1,72 +1,70 @@
-require 'tmpdir'
+# frozen_string_literal: true
+
+require "tmpdir"
 
 module ActionMailer
-  # This modules handles everything related to the delivery, from registering new
-  # delivery methods to configuring the mail object to be sent.
+  # = Action Mailer \DeliveryMethods
+  #
+  # 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
 
-      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",
+        # See breaking change in the mail gem - https://github.com/mikel/mail/commit/7e1196bd29815a0901d7290c82a332c0959b163a
+        arguments: Gem::Version.new(Mail::VERSION.version) >= Gem::Version.new("2.8.0") ? %w[-i] : "-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: %w[ -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 +77,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/deprecator.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActionMailer
+  def self.deprecator # :nodoc:
+    @deprecator ||= ActiveSupport::Deprecation.new
+  end
+end

data/lib/action_mailer/form_builder.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ActionMailer
+  # = Action Mailer Form Builder
+  #
+  # Override the default form builder for all views rendered by this
+  # mailer and any of its descendants. Accepts a subclass of
+  # ActionView::Helpers::FormBuilder.
+  #
+  # While emails typically will not include forms, this can be used
+  # by views that are shared between controllers and mailers.
+  #
+  # For more information, see +ActionController::FormBuilder+.
+  module FormBuilder
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :_default_form_builder, instance_accessor: false
+    end
+
+    module ClassMethods
+      # Set the form builder to be used as the default for all forms
+      # in the views rendered by this mailer and its subclasses.
+      #
+      # ==== Parameters
+      # * <tt>builder</tt> - Default form builder, an instance of ActionView::Helpers::FormBuilder
+      def default_form_builder(builder)
+        self._default_form_builder = builder
+      end
+    end
+
+    # Default form builder for the mailer
+    def default_form_builder
+      self.class._default_form_builder
+    end
+  end
+end

data/lib/action_mailer/gem_version.rb

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

data/lib/action_mailer/inline_preview_interceptor.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "base64"
+
+module ActionMailer
+  # = Action Mailer \InlinePreviewInterceptor
+  #
+  # 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,44 @@
-require 'active_support/core_ext/array/wrap'
+# frozen_string_literal: true
+
+require "active_support/log_subscriber"
 
 module ActionMailer
+  # = Action Mailer \LogSubscriber
+  #
+  # 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
+        if exception = event.payload[:exception_object]
+          "Failed delivery of mail #{event.payload[:message_id]} error_class=#{exception.class} error_message=#{exception.message.inspect}"
+        elsif event.payload[: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
+    subscribe_log_level :deliver, :debug
 
-    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
+    subscribe_log_level :process, :debug
 
+    # 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,48 @@
+# frozen_string_literal: true
+
+require "active_job"
+
+module ActionMailer
+  # = Action Mailer \MailDeliveryJob
+  #
+  # The +ActionMailer::MailDeliveryJob+ 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 do
+      mailer_class = arguments.first.constantize
+      mailer_class.deliver_later_queue_name
+    end
+
+    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,26 +1,42 @@
+# frozen_string_literal: true
+
 module ActionMailer
+  # = Action Mailer \MailHelper
+  #
+  # 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)
-      begin
-        require 'text/format'
-      rescue LoadError => e
-        $stderr.puts "You don't have text-format installed in your application. Please add it to your Gemfile and run bundle install"
-        raise e
-      end unless defined?(Text::Format)
-
-      formatted = text.split(/\n\r\n/).collect { |paragraph|
-        Text::Format.new(
-          :columns => 72, :first_indent => 2, :body_indent => 2, :text => paragraph
-        ).format
-      }.join("\n")
+      formatted = text.split(/\n\r?\n/).collect { |paragraph|
+        format_paragraph(paragraph)
+      }.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" }
+      output = +""
+      splits = formatted.split(/(\*+|\#+)/)
+      while line = splits.shift
+        if line.start_with?("*", "#") && splits.first&.start_with?(" ")
+          output.chomp!(" ") while output.end_with?(" ")
+          output << "  #{line} #{splits.shift.strip}\n"
+        else
+          output << line
+        end
+      end
 
-      formatted
+      output
     end
 
     # Access the mailer instance.
@@ -35,7 +51,32 @@ 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.
+    #
+    #   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"
+    def format_paragraph(text, len = 72, indent = 2)
+      sentences = [[]]
+
+      text.split.each do |word|
+        if sentences.first.present? && (sentences.last + [word]).join(" ").length > len
+          sentences << [word]
+        else
+          sentences.last << word
+        end
+      end
+
+      indentation = " " * indent
+      sentences.map! { |sentence|
+        "#{indentation}#{sentence.join(' ')}"
+      }.join "\n"
     end
   end
 end

data/lib/action_mailer/message_delivery.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module ActionMailer
+  # = Action Mailer \MessageDelivery
+  #
+  # The +ActionMailer::MessageDelivery+ class is used by
+  # ActionMailer::Base when creating a new mailer.
+  # <tt>MessageDelivery</tt> is a wrapper (+Delegator+ subclass) around a lazy
+  # created +Mail::Message+. You can get direct access to the
+  # +Mail::Message+, 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)
+
+    # 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 ActionMailer::MailDeliveryJob on
+    # the default queue. Mailer classes can customize the queue name used for the default
+    # job by assigning a +deliver_later_queue_name+ class variable, or provide a custom job
+    # by assigning a +delivery_job+. When a custom job is used, it controls the queue name.
+    #
+    #   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 ActionMailer::MailDeliveryJob on
+    # the default queue. Mailer classes can customize the queue name used for the default
+    # job by assigning a +deliver_later_queue_name+ class variable, or provide a custom job
+    # by assigning a +delivery_job+. When a custom job is used, it controls the queue name.
+    #
+    #   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
+        processed_mailer.run_callbacks(:deliver) do
+          message.deliver!
+        end
+      end
+    end
+
+    # Delivers an email:
+    #
+    #   Notifier.welcome(User.first).deliver_now
+    #
+    def deliver_now
+      processed_mailer.handle_exceptions do
+        processed_mailer.run_callbacks(:deliver) do
+          message.deliver
+        end
+      end
+    end
+
+    private
+      # Returns the processed Mailer instance. We keep this instance
+      # on hand so we can run callbacks and 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
+          @mailer_class.delivery_job.set(options).perform_later(
+            @mailer_class.name, @action.to_s, delivery_method.to_s, args: @args)
+        end
+      end
+  end
+end