1
0
Fork 0
mirror of https://github.com/rails/rails.git synced 2022-11-09 12:12:34 -05:00
rails--rails/actionmailer
Evan Phoenix 1e4be20672 Fix ActionMailer test issues
* Don't depend so much no the message in a NameError
* Reset the delivery method properly
2010-03-22 10:00:03 -07:00
..
lib Improve performance of the rendering stack by freezing formats as a sign that they shouldn't be further modified. 2010-03-19 17:20:20 +01:00
test Fix ActionMailer test issues 2010-03-22 10:00:03 -07:00
actionmailer.gemspec Load RAILS_VERSION relative to the gemspec file. 2010-03-06 21:33:28 -08:00
CHANGELOG Remove unbundle changelogs 2010-01-27 17:11:29 -08:00
install.rb Fixed spelling errors (closes #9706) [tarmo/rmm5t] 2007-09-28 14:18:47 +00:00
MIT-LICENSE Updating copyright dates on all licenses 2010-02-01 10:10:53 +11:00
Rakefile Leverage VERSION constants from gemspecs to avoid tedious updates when releasing 2010-03-02 00:32:53 -05:00
README fix usage examples and more to use new invocations 2010-02-06 09:51:53 -08:00

= Action Mailer -- Easy email delivery and testing

Action Mailer is a framework for designing email-service layers. These layers
are used to consolidate code for sending out forgotten passwords, welcome
wishes on signup, invoices for billing, and any other use case that requires
a written notification to either a person or another system.

Action Mailer is in essence a wrapper around Action Controller and the 
Mail gem.  It provides a way to make emails using templates in the same
way that Action Controller renders views using templates.

Additionally, an Action Mailer class can be used to process incoming email,
such as allowing a weblog to accept new posts from an email (which could even
have been sent from a phone).

== Sending emails

The framework works by initializing any instance variables you want to be
available in the email template, followed by a call to +mail+ to deliver
the email.

This can be as simple as:

  class Notifier < ActionMailer::Base
    delivers_from 'system@loudthinking.com'
  
    def welcome(recipient)
      @recipient = recipient
      mail(:to => recipient,
           :subject => "[Signed up] Welcome #{recipient}")
    end
  end

The body of the email is created by using an Action View template (regular
ERb) that has the instance variables that are declared in the mailer action.

So the corresponding body template for the method above could look like this:

  Hello there, 

  Mr. <%= @recipient %>

  Thank you for signing up!
  
And if the recipient was given as "david@loudthinking.com", the email 
generated would look like this:

  Date: Mon, 25 Jan 2010 22:48:09 +1100
  From: system@loudthinking.com
  To: david@loudthinking.com
  Message-ID: <4b5d84f9dd6a5_7380800b81ac29578@void.loudthinking.com.mail>
  Subject: [Signed up] Welcome david@loudthinking.com
  Mime-Version: 1.0
  Content-Type: text/plain;
  	charset="US-ASCII";
  Content-Transfer-Encoding: 7bit

  Hello there, 

  Mr. david@loudthinking.com

In previous version of rails you would call <tt>create_method_name</tt> and
<tt>deliver_method_name</tt>.  Rails 3.0 has a much simpler interface, you
simply call the method and optionally call +deliver+ on the return value.

Calling the method returns a Mail Message object:

  message = Notifier.welcome  #=> Returns a Mail::Message object
  message.deliver             #=> delivers the email

Or you can just chain the methods together like:

  Notifier.welcome.deliver    # Creates the email and sends it immediately

== Receiving emails

To receive emails, you need to implement a public instance method called receive that takes a
tmail object as its single parameter. The Action Mailer framework has a corresponding class method, 
which is also called receive, that accepts a raw, unprocessed email as a string, which it then turns
into the tmail object and calls the receive instance method.

Example:

  class Mailman < ActionMailer::Base
    def receive(email)
      page = Page.find_by_address(email.to.first)
      page.emails.create(
        :subject => email.subject, :body => email.body
      )

      if email.has_attachments?
        for attachment in email.attachments
          page.attachments.create({ 
            :file => attachment, :description => email.subject
          })
        end
      end
    end
  end

This Mailman can be the target for Postfix or other MTAs. In Rails, you would use the runner in the 
trivial case like this:

  rails runner 'Mailman.receive(STDIN.read)'

However, invoking Rails in the runner for each mail to be received is very resource intensive.  A single 
instance of Rails should be run within a daemon if it is going to be utilized to process more than just 
a limited number of email.

== Configuration

The Base class has the full list of configuration options. Here's an example:

  ActionMailer::Base.smtp_settings = {
    :address        => 'smtp.yourserver.com', # default: localhost
    :port           => '25',                  # default: 25
    :user_name      => 'user',
    :password       => 'pass',
    :authentication => :plain                 # :plain, :login or :cram_md5
  }

== Dependencies

Action Mailer requires that the Action Pack is either available to be required immediately
or is accessible as a GEM.

Additionally, Action Mailer requires the Mail gem, http://github.com/mikel/mail

== Bundled software

* Text::Format 0.63 by Austin Ziegler released under OpenSource
  Read more on http://www.halostatue.ca/ruby/Text__Format.html

== Download

The latest version of Action Mailer can be found at

* http://rubyforge.org/project/showfiles.php?group_id=361

Documentation can be found at 

* http://actionmailer.rubyonrails.org


== Installation

You can install Action Mailer with the following command.

  % [sudo] ruby install.rb

from its distribution directory.


== License

Action Mailer is released under the MIT license.


== Support

The Action Mailer homepage is http://www.rubyonrails.org. You can find
the Action Mailer RubyForge page at http://rubyforge.org/projects/actionmailer.
And as Jim from Rake says:

   Feel free to submit commits or feature requests.  If you send a patch,
   remember to update the corresponding unit tests.  If fact, I prefer
   new feature to be submitted in the form of new unit tests.