Flowdock

ActionMailer allows you to send email from your application using a mailer model and views.

Mailer Models

To use ActionMailer, you need to create a mailer model.

  $ script/generate mailer Notifier

The generated model inherits from ActionMailer::Base. Emails are defined by creating methods within the model which are then used to set variables to be used in the mail template, to change options on the mail, or to add attachments.

Examples:

 class Notifier < ActionMailer::Base
   def signup_notification(recipient)
     recipients recipient.email_address_with_name
     from       "system@example.com"
     subject    "New account information"
     body       :account => recipient
   end
 end

Mailer methods have the following configuration methods available.

  • recipients - Takes one or more email addresses. These addresses are where your email will be delivered to. Sets the To: header.
  • subject - The subject of your email. Sets the Subject: header.
  • from - Who the email you are sending is from. Sets the From: header.
  • cc - Takes one or more email addresses. These addresses will receive a carbon copy of your email. Sets the Cc: header.
  • bcc - Takes one or more email address. These addresses will receive a blind carbon copy of your email. Sets the Bcc header.
  • sent_on - The date on which the message was sent. If not set, the header wil be set by the delivery agent.
  • content_type - Specify the content type of the message. Defaults to text/plain.
  • headers - Specify additional headers to be set for the message, e.g. headers 'X-Mail-Count' => 107370.

The body method has special behavior. It takes a hash which generates an instance variable named after each key in the hash containing the value that that key points to.

So, for example, body "account" => recipient would result in an instance variable @account with the value of recipient being accessible in the view.

Mailer views

Like <a href="/rails/ActionController">ActionController,</a> each mailer class has a corresponding view directory in which each method of the class looks for a template with its name. To define a template to be used with a mailing, create an .rhtml file with the same name as the method in your mailer model. For example, in the mailer defined above, the template at app/views/notifier/signup_notification.rhtml would be used to generate the email.

Variables defined in the model are accessible as instance variables in the view.

Emails by default are sent in plain text, so a sample view for our model example might look like this:

  Hi <%= @account.name %>,
  Thanks for joining our service! Please check back often.

You can even use Action Pack helpers in these views. For example:

  You got a new note!
  <%= truncate(note.body, 25) %>

Generating URLs for mailer views

If your view includes URLs from the application, you need to use url_for in the mailing method instead of the view. Unlike controllers from Action Pack, the mailer instance doesn’t have any context about the incoming request. That’s why you need to jump this little hoop and supply all the details needed for the URL. Example:

   def signup_notification(recipient)
     recipients recipient.email_address_with_name
     from       "system@example.com"
     subject    "New account information"
     body       :account => recipient,
                :home_page => url_for(:host => "example.com", :controller => "welcome", :action => "greeting")
   end

You can now access @home_page in the template and get http://example.com/welcome/greeting.

Sending mail

Once a mailer action and template are defined, you can deliver your message or create it and save it for delivery later:

  Notifier.deliver_signup_notification(david) # sends the email
  mail = Notifier.create_signup_notification(david)  # => a tmail object
  Notifier.deliver(mail)

You never instantiate your mailer class. Rather, your delivery instance methods are automatically wrapped in class methods that start with the word deliver_ followed by the name of the mailer method that you would like to deliver. The signup_notification method defined above is delivered by invoking Notifier.deliver_signup_notification.

HTML email

To send mail as HTML, make sure your view (the .rhtml file) generates HTML and set the content type to html.

  class MyMailer < ActionMailer::Base
    def signup_notification(recipient)
      recipients recipient.email_address_with_name
      subject    "New account information"
      body       "account" => recipient
      from       "system@example.com"
      content_type "text/html"   #    Here's where the magic happens
    end
  end

Multipart email

You can explicitly specify multipart messages:

  class ApplicationMailer < ActionMailer::Base
    def signup_notification(recipient)
      recipients      recipient.email_address_with_name
      subject         "New account information"
      from            "system@example.com"

      part :content_type => "text/html",
        :body => render_message("signup-as-html", :account => recipient)

      part "text/plain" do |p|
        p.body = render_message("signup-as-plain", :account => recipient)
        p.transfer_encoding = "base64"
      end
    end
  end

Multipart messages can also be used implicitly because ActionMailer will automatically detect and use multipart templates, where each template is named after the name of the action, followed by the content type. Each such detected template will be added as separate part to the message.

For example, if the following templates existed:

  • signup_notification.text.plain.rhtml
  • signup_notification.text.html.rhtml
  • signup_notification.text.xml.rxml
  • signup_notification.text.x-yaml.rhtml

Each would be rendered and added as a separate part to the message, with the corresponding content type. The same body hash is passed to each template.

Attachments

Attachments can be added by using the attachment method.

Example:

  class ApplicationMailer < ActionMailer::Base
    # attachments
    def signup_notification(recipient)
      recipients      recipient.email_address_with_name
      subject         "New account information"
      from            "system@example.com"

      attachment :content_type => "image/jpeg",
        :body => File.read("an-image.jpg")

      attachment "application/pdf" do |a|
        a.body = generate_your_pdf_here()
      end
    end
  end

Configuration options

These options are specified on the class level, like ActionMailer::Base.template_root = "/my/templates"

  • template_root - template root determines the base from which template references will be made.
  • logger - the logger is used for generating information on the mailing run if available. Can be set to nil for no logging. Compatible with both Ruby’s own Logger and Log4r loggers.
  • smtp_settings - Allows detailed configuration for :smtp delivery method:
    • :address Allows you to use a remote mail server. Just change it from its default "localhost" setting.
    • :port On the off chance that your mail server doesn’t run on port 25, you can change it.
    • :domain If you need to specify a HELO domain, you can do it here.
    • :user_name If your mail server requires authentication, set the username in this setting.
    • :password If your mail server requires authentication, set the password in this setting.
    • :authentication If your mail server requires authentication, you need to specify the authentication type here. This is a symbol and one of :plain, :login, :cram_md5
  • sendmail_settings - Allows you to override options for the :sendmail delivery method
    • :location The location of the sendmail executable, defaults to "/usr/sbin/sendmail"
    • :arguments The command line arguments
  • raise_delivery_errors - whether or not errors should be raised if the email fails to be delivered.
  • delivery_method - Defines a delivery method. Possible values are :smtp (default), :sendmail, and :test.
  • perform_deliveries - Determines whether deliver_* methods are actually carried out. By default they are, but this can be turned off to help functional testing.
  • deliveries - Keeps an array of all the emails sent out through the Action Mailer with delivery_method :test. Most useful for unit and functional testing.
  • default_charset - The default charset used for the body and to encode the subject. Defaults to UTF-8. You can also pick a different charset from inside a method with @charset.
  • default_content_type - The default content type used for the main part of the message. Defaults to "text/plain". You can also pick a different content type from inside a method with @content_type.
  • default_mime_version - The default mime version used for the message. Defaults to "1.0". You can also pick a different value from inside a method with @mime_version.
  • default_implicit_parts_order - When a message is built implicitly (i.e. multiple parts are assembled from templates which specify the content type in their filenames) this variable controls how the parts are ordered. Defaults to ["text/html", "text/enriched", "text/plain"]. Items that appear first in the array have higher priority in the mail client and appear last in the mime encoded message. You can also pick a different order from inside a method with @implicit_parts_order.
Show files where this class is defined (1 file)
Register or log in to add new notes.
July 24, 2008
8 thanks

render template file different from your action (method) name

In some cases you have to avoid rails magic that uses template names named as your ActionMailer method.

rails magic

def daily_notification
  # ...
end
# will look for daily_notification.erb

def weekly_notification
  # ...
end
# will look for weekly_notification.erb

your case

Just give necessary value to @template instance variable.

def setup
  # ...
  @template = 'notification'
end

def daily_notification
  # ...
end
# will look for notification.erb

def weekly_notification
  # ...
end
# will look for notification.erb
March 21, 2009
7 thanks

Use helpers in your ActionMailer views

It’s very easy to give your mailer access to helpers:

# Let your mailer user the ApplicationHelper methods
class MyMailer < ActionMailer::Base
  helper :application
end
July 30, 2008
7 thanks

Using gmail SMTP server to send mail

First you would need to sign up with Google Apps, which is a very painless process:

http://www.google.com/a/cpanel/domain/new

Next you need to install a plugin that will allow ActionMailer to make a secure connection to google:

script/plugin install git://github.com/caritos/action_mailer_tls.git

We need this due to transport layer security used by google.

Lastly all you need to do is place this in your environment.rb file and modify it to your settings:

ActionMailer::Base.smtp_settings = {
 :address => "smtp.gmail.com",
 :port => 587,
 :domain => "your.domain_at_google.com",
 :authentication => :plain,
 :user_name => "google_username",
 :password => "password"
}
May 8, 2009
2 thanks

Using gmail SMTP server to send mail

If you’re running Rails >= 2.2.1 [RC2] and Ruby 1.8.7, you don’t need plugin below. Ruby 1.8.7 supports SMTP TLS and Rails 2.2.1 ships with an option to enable it if you’re running Ruby 1.8.7.

All You need to do is:

ActionMailer::Base.smtp_settings = {
  :enable_starttls_auto => true
}
November 5, 2008 - (v1.0.0 - v2.1.0)
1 thank

james' note incorrect

The render method in ActionMailer is infact a private method, in all versions (including the new Rails 2.2).

However, spectators note about @template works well. Thanks.

August 10, 2009
0 thanks

Content type for emails with attachments

Be aware that if you want to send emails with attachments, you probably want to use the content type multipart/mixed for the overall email.

The MIME time multipart/alternative is intended for emails where each part is a different representation of the same message.

After following the 2.3.2 documentation we used multipart/alternative to attach files to our mails, however this then caused Hotmail to ignore the attachments. It turns out it thought they were all alternative versions of the HTML content (which it could already display, so the alternatives weren’t necessary)

July 25, 2008 - (v1.0.0 - v2.1.0)
0 thanks

render template file different from your action (method) name - alternative

Alternative ways to render templates for actions

# Renders the template for foo (foo.html.erb, foo.haml.erb, foo.text.html.haml, whatever :P)
def foo
end

# Renders the template that would be rendered in foo
# (but without the foo controller action being invoked)
def bar
  render :action => 'foo'
end

# Similar to what bar does, but render's a specifically named template
def roar
  render :template => 'foo'
end

# Similar to what roar does, but render's a template
# from outside of the current controller's views directory
def boo
  render :template => 'global/something'
end
April 27, 2010
0 thanks

smtp syntax error 555 5.5.2

If You’re seeing a Net::SMTPFatalError (555 5.5.2 Syntax error ...) than You should check the email’s from header ! You probably have brackets while calling the from attribute setter :

Works in Rails < 2.3.3

def signup_notification(recipient)
  recipients      recipient.email_address_with_name
  subject         "New account information"
  from            %("My App" <no-reply@myapp.com>)
end

Works in Rails 2.3.5

def signup_notification(recipient)
  recipients      recipient.email_address_with_name
  subject         "New account information"
  from            'no-reply@myapp.com' # no <> brackets !
end

in Rails 2.3.3 the from email address will get wrapped with angle brackets, thus it must not have them within the address.

November 5, 2008
0 thanks

re: james' note incorrect

kieran is correct, my note is incorrect, it was not meant for ActionMailer::Base

November 12, 2011 - (<= v2.3.8)
0 thanks

Specify attachment names

If you want to give your attachment a name, you can do this:

attachment :filename => 'my_file.txt', :body => File.read('/var/null')

It will appear to the recipient as a file named “my_file.txt” rather than something awful like “noname 1”.

August 22, 2012 - (v3.2.8)
0 thanks

Using Amazon Simple Email Service with ActionMailer

First of all, get all the necessary SES credentials and verify your email address.

Then, just edit your config/environments/*.rb files:

config.action_mailer.delivery_method = :smtp
config.action_mailer.smtp_settings = {
    address: 'email-smtp.us-east-1.amazonaws.com',
    user_name: 'your-ses-smtp-user-name',
    password: 'your-ses-smtp-password',
    authentication: :login,
    enable_starttls_auto: true
}

And that’s it!