actionmailer 5.2.3

data/lib/action_mailer/collector.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+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
+
+    def initialize(context, &block)
+      @context = context
+      @responses = []
+      @default_render = block
+    end
+
+    def any(*args, &block)
+      options = args.extract_options!
+      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.formats = [mime.to_sym]
+      options[:body] = block_given? ? yield : @default_render.call
+      @responses << options
+    end
+  end
+end

data/lib/action_mailer/delivery_job.rb

@@ -0,0 +1,36 @@
+# 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
+
+    def perform(mailer, mail_method, delivery_method, *args) #:nodoc:
+      mailer.constantize.public_send(mail_method, *args).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/delivery_methods.rb

@@ -0,0 +1,82 @@
+# 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.
+  module DeliveryMethods
+    extend ActiveSupport::Concern
+
+    included do
+      # Do not make this inheritable, because we always want it to propagate
+      cattr_accessor :raise_delivery_errors, default: true
+      cattr_accessor :perform_deliveries, default: true
+      cattr_accessor :deliver_later_queue_name, default: :mailers
+
+      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
+
+      add_delivery_method :file, Mail::FileDelivery,
+        location: defined?(Rails.root) ? "#{Rails.root}/tmp/mails" : "#{Dir.tmpdir}/mails"
+
+      add_delivery_method :sendmail, Mail::Sendmail,
+        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
+
+      # 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'
+      def add_delivery_method(symbol, klass, default_options = {})
+        class_attribute(:"#{symbol}_settings") unless respond_to?(:"#{symbol}_settings")
+        send(:"#{symbol}_settings=", default_options)
+        self.delivery_methods = delivery_methods.merge(symbol.to_sym => klass).freeze
+      end
+
+      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]
+            mail.delivery_method(klass, (send(:"#{method}_settings") || {}).merge(options || {}))
+          else
+            raise "Invalid delivery method #{method.inspect}"
+          end
+        else
+          mail.delivery_method(method)
+        end
+
+        mail.perform_deliveries    = perform_deliveries
+        mail.raise_delivery_errors = raise_delivery_errors
+      end
+    end
+
+    def wrap_delivery_behavior!(*args) # :nodoc:
+      self.class.wrap_delivery_behavior(message, *args)
+    end
+  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 = 5
+    MINOR = 2
+    TINY  = 3
+    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
+  # 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
+      def message
+        @message
+      end
+
+      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

@@ -0,0 +1,41 @@
+# 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)
+      info do
+        recipients = Array(event.payload[:to]).join(", ")
+        "Sent mail to #{recipients} (#{event.duration.round(1)}ms)"
+      end
+
+      debug { event.payload[:mail] }
+    end
+
+    # An email was received.
+    def receive(event)
+      info { "Received mail (#{event.duration.round(1)}ms)" }
+      debug { event.payload[:mail] }
+    end
+
+    # 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

data/lib/action_mailer/mail_helper.rb

@@ -0,0 +1,72 @@
+# 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
+    # 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|
+        format_paragraph(paragraph)
+      }.join("\n\n")
+
+      # Make list points stand on their own line
+      formatted.gsub!(/[ ]*([*]+) ([^*]*)/) { "  #{$1} #{$2.strip}\n" }
+      formatted.gsub!(/[ ]*([#]+) ([^#]*)/) { "  #{$1} #{$2.strip}\n" }
+
+      formatted
+    end
+
+    # Access the mailer instance.
+    def mailer
+      @_controller
+    end
+
+    # Access the message instance.
+    def message
+      @_message
+    end
+
+    # Access the message attachments list.
+    def 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,144 @@
+# 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
+
+    # 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, marshaling).
+    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)
+    #
+    # 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
+    #
+    # 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)
+    #
+    # 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.
+    #
+    # 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
+          args = @mailer_class.name, @action.to_s, delivery_method.to_s, *@args
+          job = @mailer_class.delivery_job
+          job.set(options).perform_later(*args)
+        end
+      end
+  end
+end