class ActionMailer::MessageDelivery

Notifier.welcome(User.first).message # a Mail::Message object
Notifier.welcome(User.first).deliver_later # enqueue email delivery as a job through Active Job
Notifier.welcome(User.first).deliver_now # sends the email
Notifier.welcome(User.first) # an ActionMailer::MessageDelivery object
through Active Job.
Mail::Message, deliver the email or schedule the email to be sent
created Mail::Message. You can get direct access to the
MessageDelivery is a wrapper (Delegator subclass) around a lazy
ActionMailer::Base when creating a new mailer.
The ActionMailer::MessageDelivery class is used by
= Action Mailer MessageDelivery

def __getobj__ # :nodoc:

:nodoc:
Method calls are delegated to the Mail::Message that's ready to deliver. 
def __getobj__ # :nodoc:
  @mail_message ||= processed_mailer.message
end

def __setobj__(mail_message) # :nodoc:

:nodoc:
Unused except for delegator internals (dup, marshalling). 
def __setobj__(mail_message) # :nodoc:
  @mail_message = mail_message
end

def deliver_later(options = {})

end
self.delivery_job = RegistrationDeliveryJob
class AccountRegistrationMailer < ApplicationMailer

by assigning a +delivery_job+. When a custom job is used, it controls the queue name.
job by assigning a +deliver_later_queue_name+ class variable, or provide a custom job
the default queue. Mailer classes can customize the queue name used for the default
By default, the email will be enqueued using ActionMailer::MailDeliveryJob on

* :priority - Enqueues the email with the specified priority
* :queue - Enqueue the email on the specified queue.
* :wait_until - Enqueue the email to be delivered at (after) a specific date / time.
* :wait - Enqueue the email to be delivered with a delay.

Options:

Notifier.welcome(User.first).deliver_later(priority: 10)
Notifier.welcome(User.first).deliver_later(wait_until: 10.hours.from_now)
Notifier.welcome(User.first).deliver_later(wait: 1.hour)
Notifier.welcome(User.first).deliver_later

job runs it will send the email using +deliver_now+.
Enqueues the email to be delivered through Active Job. When the 
def deliver_later(options = {})
  enqueue_delivery :deliver_now, options
end

def deliver_later!(options = {})

end
self.delivery_job = RegistrationDeliveryJob
class AccountRegistrationMailer < ApplicationMailer

by assigning a +delivery_job+. When a custom job is used, it controls the queue name.
job by assigning a +deliver_later_queue_name+ class variable, or provide a custom job
the default queue. Mailer classes can customize the queue name used for the default
By default, the email will be enqueued using ActionMailer::MailDeliveryJob on

* :priority - Enqueues the email with the specified priority
* :queue - Enqueue the email on the specified queue
* :wait_until - Enqueue the email to be delivered at (after) a specific date / time
* :wait - Enqueue the email to be delivered with a delay

Options:

Notifier.welcome(User.first).deliver_later!(priority: 10)
Notifier.welcome(User.first).deliver_later!(wait_until: 10.hours.from_now)
Notifier.welcome(User.first).deliver_later!(wait: 1.hour)
Notifier.welcome(User.first).deliver_later!

and +raise_delivery_errors+, so use with caution.
that the message will be sent bypassing checking +perform_deliveries+
job runs it will send the email using +deliver_now!+. That means
Enqueues the email to be delivered through Active Job. When the 
def deliver_later!(options = {})
  enqueue_delivery :deliver_now!, options
end

def deliver_now


Notifier.welcome(User.first).deliver_now

Delivers an email: 
def deliver_now
  processed_mailer.handle_exceptions do
    processed_mailer.run_callbacks(:deliver) do
      message.deliver
    end
  end
end

def deliver_now!


Notifier.welcome(User.first).deliver_now!

so use with caution.
Delivers an email without checking +perform_deliveries+ and +raise_delivery_errors+, 
def deliver_now!
  processed_mailer.handle_exceptions do
    processed_mailer.run_callbacks(:deliver) do
      message.deliver!
    end
  end
end

def enqueue_delivery(delivery_method, options = {}) 

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

def initialize(mailer_class, action, *args) # :nodoc:

:nodoc: 
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

def message

Returns the resulting Mail::Message 
def message
  __getobj__
end

def processed?

Was the delegate loaded, causing the mailer action to be processed? 
def processed?
  @processed_mailer || @mail_message
end

def processed_mailer

on hand so we can run callbacks and delegate exception handling to it.
Returns the processed Mailer instance. We keep this instance 
def processed_mailer
  @processed_mailer ||= @mailer_class.new.tap do |mailer|
    mailer.process @action, *@args
  end
end