fix bad logic in determining if in rails app subdir

Signed-off-by: David Heinemeier Hansson <david@loudthinking.com>

.gitignore

@@ -1,20 +1,21 @@
+*.gem
+pkg
+.bundle
+Gemfile.lock
 debug.log
 doc/rdoc
+activemodel/doc
 activeresource/doc
 activerecord/doc
 actionpack/doc
 actionmailer/doc
 activesupport/doc
-activeresource/pkg
-activerecord/pkg
-actionpack/pkg
-actionmailer/pkg
-activesupport/pkg
-railties/pkg
+activemodel/test/fixtures/fixture_database.sqlite3
+actionpack/test/tmp
+activesupport/test/fixtures/isolation_test
 railties/test/500.html
-railties/doc/guides/html/images
-railties/doc/guides/html/stylesheets
+railties/test/fixtures/tmp
+railties/test/initializer/root/log
+railties/doc
 railties/guides/output
-*.rbc
-*.swp
-*.swo
+railties/tmp

Gemfile

@@ -0,0 +1,59 @@
+source 'http://rubygems.org'
+
+if ENV['AREL']
+  gem "arel", :path => ENV['AREL']
+else
+  gem "arel", :git => "git://github.com/rails/arel.git"
+end
+
+gem "rails", :path => File.dirname(__FILE__)
+
+gem "rake",  ">= 0.8.7"
+gem "mocha", ">= 0.9.8"
+gem "rdoc",  ">= 2.5.9"
+gem "horo"
+
+# AS
+gem "memcache-client", ">= 1.8.5"
+
+# AM
+gem "text-format", "~> 1.0.0"
+
+platforms :mri_18 do
+  gem "system_timer"
+  gem "ruby-debug", ">= 0.10.3"
+end
+
+platforms :ruby do
+  gem 'json'
+  gem 'yajl-ruby'
+  gem "nokogiri", ">= 1.4.2"
+
+  # AR
+  gem "sqlite3-ruby", "~> 1.3.1", :require => 'sqlite3'
+
+  group :db do
+    gem "pg", ">= 0.9.0"
+    gem "mysql", ">= 2.8.1"
+  end
+end
+
+platforms :jruby do
+  gem "ruby-debug", ">= 0.10.3"
+
+  gem "activerecord-jdbcsqlite3-adapter"
+
+  group :db do
+    gem "activerecord-jdbcmysql-adapter"
+    gem "activerecord-jdbcpostgresql-adapter"
+  end
+end
+
+env 'CI' do
+  gem "nokogiri", ">= 1.4.2"
+
+  platforms :ruby_18 do
+    # fcgi gem doesn't compile on 1.9
+    gem "fcgi", ">= 0.8.8"
+  end
+end

RAILS_VERSION

@@ -0,0 +1 @@
+3.0.0.rc

README.rdoc

@@ -0,0 +1,58 @@
+== Welcome to Rails
+
+Rails is a web-application framework that includes everything needed to create
+database-backed web applications according to the Model-View-Control pattern.
+
+This pattern splits the view (also called the presentation) into "dumb"
+templates that are primarily responsible for inserting pre-built data in between
+HTML tags. The model contains the "smart" domain objects (such as Account,
+Product, Person, Post) that holds all the business logic and knows how to
+persist themselves to a database. The controller handles the incoming requests
+(such as Save New Account, Update Product, Show Post) by manipulating the model
+and directing data to the view.
+
+In Rails, the model is handled by what's called an object-relational mapping
+layer entitled Active Record. This layer allows you to present the data from
+database rows as objects and embellish these data objects with business logic
+methods. You can read more about Active Record in
+link:files/vendor/rails/activerecord/README.html.
+
+The controller and view are handled by the Action Pack, which handles both
+layers by its two parts: Action View and Action Controller. These two layers
+are bundled in a single package due to their heavy interdependence. This is
+unlike the relationship between the Active Record and Action Pack that is much
+more separate. Each of these packages can be used independently outside of
+Rails. You can read more about Action Pack in
+link:files/vendor/rails/actionpack/README.html.
+
+
+== Getting Started
+
+1. Install Rails at the command prompt if you haven't yet:
+       <tt>gem install rails</tt>
+
+2. At the command prompt, create a new Rails application:
+       <tt>rails new myapp</tt> (where <tt>myapp</tt> is the application name)
+
+3. Change directory to <tt>myapp</tt> and start the web server:
+       <tt>cd myapp; rails server</tt> (run with --help for options)
+
+4. Go to http://localhost:3000/ and you'll see:
+       "Welcome aboard: You're riding Ruby on Rails!"
+
+5. Follow the guidelines to start developing your application. You can find 
+the following resources handy:
+
+* The README file created within your application
+* The Getting Started Guide: http://guides.rubyonrails.org/getting_started.html
+* Ruby on Rails Tutorial Book: http://www.railstutorial.org/
+
+
+== Contributing
+
+Check out the contributing guide at http://edgeguides.rubyonrails.org/contributing_to_rails.html
+
+
+== License
+
+Ruby on Rails is released under the MIT license.

Rakefile

@@ -1,69 +1,113 @@
+gem 'rdoc', '>= 2.5.9'
+require 'rdoc'
+
 require 'rake'
-require 'rake/rdoctask'
-require 'rake/contrib/sshpublisher'
+require 'rdoc/task'
+require 'rake/gempackagetask'
 
-env = %(PKG_BUILD="#{ENV['PKG_BUILD']}") if ENV['PKG_BUILD']
-
-PROJECTS = %w(activesupport actionpack actionmailer activeresource activerecord railties)
-
-Dir["#{File.dirname(__FILE__)}/*/lib/*/version.rb"].each do |version_path|
-  require version_path
-end
+PROJECTS = %w(activesupport activemodel actionpack actionmailer activeresource activerecord railties)
 
 desc 'Run all tests by default'
-task :default => :test
+task :default => %w(test test:isolated)
 
-%w(test rdoc pgem package release).each do |task_name|
+%w(test test:isolated package gem).each do |task_name|
   desc "Run #{task_name} task for all projects"
   task task_name do
+    errors = []
     PROJECTS.each do |project|
-      system %(cd #{project} && #{env} #{$0} #{task_name})
+      system(%(cd #{project} && #{$0} #{task_name})) || errors << project
     end
+    fail("Errors in #{errors.join(', ')}") unless errors.empty?
   end
 end
 
+desc "Smoke-test all projects"
+task :smoke do
+  (PROJECTS - %w(activerecord)).each do |project|
+    system %(cd #{project} && #{$0} test:isolated)
+  end
+  system %(cd activerecord && #{$0} sqlite3:isolated_test)
+end
+
+spec = eval(File.read('rails.gemspec'))
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "Release all gems to gemcutter. Package rails, package & push components, then push rails"
+task :release => :release_projects do
+  require 'rake/gemcutter'
+  Rake::Gemcutter::Tasks.new(spec).define
+  Rake::Task['gem:push'].invoke
+end
+
+desc "Release all components to gemcutter."
+task :release_projects => :package do
+  errors = []
+  PROJECTS.each do |project|
+    system(%(cd #{project} && #{$0} release)) || errors << project
+  end
+  fail("Errors in #{errors.join(', ')}") unless errors.empty?
+end
+
+desc "Install gems for all projects."
+task :install => :gem do
+  version = File.read("RAILS_VERSION").strip
+  (PROJECTS - ["railties"]).each do |project|
+    puts "INSTALLING #{project}"
+    system("gem install #{project}/pkg/#{project}-#{version}.gem --no-ri --no-rdoc")
+  end
+  system("gem install railties/pkg/railties-#{version}.gem --no-ri --no-rdoc")
+  system("gem install pkg/rails-#{version}.gem --no-ri --no-rdoc")
+end
 
 desc "Generate documentation for the Rails framework"
-Rake::RDocTask.new do |rdoc|
+RDoc::Task.new do |rdoc|
   rdoc.rdoc_dir = 'doc/rdoc'
   rdoc.title    = "Ruby on Rails Documentation"
 
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.options << '-A cattr_accessor=object'
-  rdoc.options << '--charset' << 'utf-8'
+  rdoc.options << '-f' << 'horo'
+  rdoc.options << '-c' << 'utf-8'
+  rdoc.options << '-m' << 'README.rdoc'
 
-  rdoc.template = ENV['template'] ? "#{ENV['template']}.rb" : './doc/template/horo'
+  rdoc.rdoc_files.include('README.rdoc')
 
   rdoc.rdoc_files.include('railties/CHANGELOG')
   rdoc.rdoc_files.include('railties/MIT-LICENSE')
-  rdoc.rdoc_files.include('railties/README')
-  rdoc.rdoc_files.include('railties/lib/{*.rb,commands/*.rb,rails/*.rb,rails_generator/*.rb}')
+  rdoc.rdoc_files.include('railties/README.rdoc')
+  rdoc.rdoc_files.include('railties/lib/**/*.rb')
+  rdoc.rdoc_files.exclude('railties/lib/rails/generators/**/templates/*')
 
-  rdoc.rdoc_files.include('activerecord/README')
+  rdoc.rdoc_files.include('activerecord/README.rdoc')
   rdoc.rdoc_files.include('activerecord/CHANGELOG')
   rdoc.rdoc_files.include('activerecord/lib/active_record/**/*.rb')
   rdoc.rdoc_files.exclude('activerecord/lib/active_record/vendor/*')
 
-  rdoc.rdoc_files.include('activeresource/README')
+  rdoc.rdoc_files.include('activeresource/README.rdoc')
   rdoc.rdoc_files.include('activeresource/CHANGELOG')
   rdoc.rdoc_files.include('activeresource/lib/active_resource.rb')
   rdoc.rdoc_files.include('activeresource/lib/active_resource/*')
 
-  rdoc.rdoc_files.include('actionpack/README')
+  rdoc.rdoc_files.include('actionpack/README.rdoc')
   rdoc.rdoc_files.include('actionpack/CHANGELOG')
   rdoc.rdoc_files.include('actionpack/lib/action_controller/**/*.rb')
+  rdoc.rdoc_files.include('actionpack/lib/action_dispatch/**/*.rb')
   rdoc.rdoc_files.include('actionpack/lib/action_view/**/*.rb')
   rdoc.rdoc_files.exclude('actionpack/lib/action_controller/vendor/*')
 
-  rdoc.rdoc_files.include('actionmailer/README')
+  rdoc.rdoc_files.include('actionmailer/README.rdoc')
   rdoc.rdoc_files.include('actionmailer/CHANGELOG')
   rdoc.rdoc_files.include('actionmailer/lib/action_mailer/base.rb')
   rdoc.rdoc_files.exclude('actionmailer/lib/action_mailer/vendor/*')
 
-  rdoc.rdoc_files.include('activesupport/README')
+  rdoc.rdoc_files.include('activesupport/README.rdoc')
   rdoc.rdoc_files.include('activesupport/CHANGELOG')
   rdoc.rdoc_files.include('activesupport/lib/active_support/**/*.rb')
   rdoc.rdoc_files.exclude('activesupport/lib/active_support/vendor/*')
+
+  rdoc.rdoc_files.include('activemodel/README.rdoc')
+  rdoc.rdoc_files.include('activemodel/CHANGELOG')
+  rdoc.rdoc_files.include('activemodel/lib/active_model/**/*.rb')
 end
 
 # Enhance rdoc task to copy referenced images also
@@ -74,8 +118,34 @@ end
 
 desc "Publish API docs for Rails as a whole and for each component"
 task :pdoc => :rdoc do
-  Rake::SshDirPublisher.new("wrath.rubyonrails.org", "public_html/api", "doc/rdoc").upload
+  require 'rake/contrib/sshpublisher'
+  Rake::SshDirPublisher.new("rails@api.rubyonrails.org", "public_html/api", "doc/rdoc").upload
+end
+
+task :update_versions do
+  require File.dirname(__FILE__) + "/version"
+
+  File.open("RAILS_VERSION", "w") do |f|
+    f.write Rails::VERSION::STRING + "\n"
+  end
+
+  constants = {
+    "activesupport"   => "ActiveSupport",
+    "activemodel"     => "ActiveModel",
+    "actionpack"      => "ActionPack",
+    "actionmailer"    => "ActionMailer",
+    "activeresource"  => "ActiveResource",
+    "activerecord"    => "ActiveRecord",
+    "railties"        => "Rails"
+  }
+
+  version_file = File.read("version.rb")
+
   PROJECTS.each do |project|
-    system %(cd #{project} && #{env} #{$0} pdoc)
+    Dir["#{project}/lib/*/version.rb"].each do |file|
+      File.open(file, "w") do |f|
+        f.write version_file.gsub(/Rails/, constants[project])
+      end
+    end
   end
 end

actionmailer/CHANGELOG

@@ -1,3 +1,68 @@
+*Rails 3.0.0 [release candidate] (July 26th, 2010)*
+
+* No material changes
+
+
+*Rails 3.0.0 [beta 4] (June 8th, 2010)*
+
+* subject is automatically looked up on I18n using mailer_name and action_name as scope as in t(".subject") [JK]
+
+* Changed encoding behaviour of mail, so updated tests in actionmailer and bumped mail version to 2.2.1 [ML]
+
+* Added ability to pass Proc objects to the defaults hash [ML]
+
+
+*Rails 3.0.0 [beta 3] (April 13th, 2010)*
+
+* Removed all quoting.rb type files from ActionMailer and put Mail 2.2.0 in instead [ML]
+
+* Lot of updates to various test cases that now work better with the new Mail and so have different expectations
+
+
+*Rails 3.0.0 [beta 2] (April 1st, 2010)*
+
+* Added interceptors and observers from Mail [ML]
+
+    ActionMailer::Base.register_interceptor calls Mail.register_interceptor
+    ActionMailer::Base.register_observer calls Mail.register_observer
+
+* Mail::Part now no longer has nil as a default charset, it is always set to something, and defaults to UTF-8
+
+* Added explict setting of charset in set_fields! method to make sure Mail has the user defined default
+
+* Removed quoting.rb and refactored for Mail to take responsibility of all quoting and auto encoding requirements for the header.
+
+* Fixed several tests which had incorrect encoding.
+
+* Changed all utf-8 to UTF-8 for consistency
+
+* Whole new API added with tests.  See base.rb for full details.  Old API is deprecated.
+
+
+*Rails 3.0.0 [beta 1] (February 4, 2010)*
+
+* The Mail::Message class has helped methods for all the field types that return 'common' defaults for the common use case, so to get the subject, mail.subject will give you a string, mail.date will give you a DateTime object, mail.from will give you an array of address specs (mikel@test.lindsaar.net) etc.  If you want to access the field object itself, call mail[:field_name] which will return the field object you want, which you can then chain, like mail[:from].formatted
+
+* Mail#content_type now returns the content_type field as a string. If you want the mime type of a mail, then you call Mail#mime_type (eg, text/plain), if you want the parameters of the content type field, you call Mail#content_type_parameters which gives you a hash, eg {'format' => 'flowed', 'charset' => 'utf-8'}
+
+* ActionMailer::Base :default_implicit_parts_order now is in the sequence of the order you want, no reversing of ordering takes place.  The default order now is text/plain, then text/enriched, then text/html and then any other part that is not one of these three.
+
+* Mail does not have "quoted_body", "quoted_subject" etc.  All of these are accessed via body.encoded, subject.encoded etc
+
+* Every object in a Mail object returns an object, never a string.  So Mail.body returns a Mail::Body class object, need to call #encoded or #decoded to get the string you want.
+* Mail::Message#set_content_type does not exist, it is simply Mail::Message#content_type
+
+* Every mail message gets a unique message_id unless you specify one, had to change all the tests that check for equality with expected.encoded == actual.encoded to first replace their message_ids with control values
+
+* Mail now has a proper concept of parts, remove the ActionMailer::Part and ActionMailer::PartContainer classes
+
+* Calling #encoded on any object returns it as a string ready to go into the output stream of an email, this means it includes the \r\n at the end of the lines and the object is pre-wrapped with \r\n\t if it is a header field.  Also, the "encoded" value includes the field name if it is a header field.
+
+* Attachments are only the actual attachment, with filename etc.  A part contains an attachment.  The part has the content_type etc.  So attachments.last.content_type is invalid.  But parts.last.content_type
+
+* There is no idea of a "sub_head" in Mail.  A part is just a Message with some extra functionality, so it just has a "header" like a normal mail message
+
+
 *2.3.2 [Final] (March 15, 2009)*
 
 * Fixed that ActionMailer should send correctly formatted Return-Path in MAIL FROM for SMTP #1842 [Matt Jones]

actionmailer/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2004-2009 David Heinemeier Hansson
+Copyright (c) 2004-2010 David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

actionmailer/README.rdoc

@@ -5,51 +5,72 @@ 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 setting up all the email details, except the body,
-in methods on the service layer. Subject, recipients, sender, and timestamp
-are all set up this way. An example of such a method:
+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.
 
-  def signed_up(recipient)
-    recipients recipient
-    subject    "[Signed up] Welcome #{recipient}"
-    from       "system@loudthinking.com"
-    body       :recipient => recipient
+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 content of the body hash parameter available as instance variables. 
+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: Sun, 12 Dec 2004 00:00:00 +0100
+  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
 
-You never actually call the instance methods like signed_up directly. Instead,
-you call class methods like deliver_* and create_* that are automatically
-created for each instance method. So if the signed_up method sat on
-ApplicationMailer, it would look like this:
+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.
 
-  ApplicationMailer.create_signed_up("david@loudthinking.com")  # => tmail object for testing
-  ApplicationMailer.deliver_signed_up("david@loudthinking.com") # sends the email
-  ApplicationMailer.new.signed_up("david@loudthinking.com")     # won't work!
+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
 
@@ -80,7 +101,7 @@ Example:
 This Mailman can be the target for Postfix or other MTAs. In Rails, you would use the runner in the 
 trivial case like this:
 
-  ./script/runner 'Mailman.receive(STDIN.read)'
+  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 
@@ -98,39 +119,16 @@ The Base class has the full list of configuration options. Here's an example:
     :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.
+== Download and installation
 
+The latest version of Action Mailer can be installed with Rubygems:
 
-== Bundled software
+  % [sudo] gem install actionmailer
 
-* tmail 0.10.8 by Minero Aoki released under LGPL
-  Read more on http://i.loveruby.net/en/prog/tmail.html
+Source code can be downloaded as part of the Rails project on GitHub
 
-* 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.
+* http://github.com/rails/rails/tree/master/actionmailer/
 
 
 == License
@@ -140,10 +138,10 @@ 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:
+API documentation is at
 
-   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.
+* http://api.rubyonrails.com
+
+Bug reports and feature requests can be filed with the rest for the Ruby on Rails project here:
+
+* https://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets

actionmailer/Rakefile

@@ -1,21 +1,10 @@
-require 'rubygems'
+gem 'rdoc', '>= 2.5.9'
+require 'rdoc'
 require 'rake'
 require 'rake/testtask'
-require 'rake/rdoctask'
+require 'rdoc/task'
 require 'rake/packagetask'
 require 'rake/gempackagetask'
-require 'rake/contrib/sshpublisher'
-require File.join(File.dirname(__FILE__), 'lib', 'action_mailer', 'version')
-
-PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
-PKG_NAME      = 'actionmailer'
-PKG_VERSION   = ActionMailer::VERSION::STRING + PKG_BUILD
-PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
-
-RELEASE_NAME  = "REL #{PKG_VERSION}"
-
-RUBY_FORGE_PROJECT = "actionmailer"
-RUBY_FORGE_USER    = "webster132"
 
 desc "Default Task"
 task :default => [ :test ]
@@ -23,76 +12,41 @@ task :default => [ :test ]
 # Run the unit tests
 Rake::TestTask.new { |t|
   t.libs << "test"
-  t.pattern = 'test/*_test.rb'
-  t.verbose = true
-  t.warning = false
+  t.pattern = 'test/**/*_test.rb'
+  t.warning = true
 }
 
+namespace :test do
+  task :isolated do
+    ruby = File.join(*RbConfig::CONFIG.values_at('bindir', 'RUBY_INSTALL_NAME'))
+    Dir.glob("test/**/*_test.rb").all? do |file|
+      system(ruby, '-Ilib:test', file)
+    end or raise "Failures"
+  end
+end
 
 # Generate the RDoc documentation
-Rake::RDocTask.new { |rdoc|
+RDoc::Task.new { |rdoc|
   rdoc.rdoc_dir = 'doc'
   rdoc.title    = "Action Mailer -- Easy email delivery and testing"
-  rdoc.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
   rdoc.options << '--charset' << 'utf-8'
-  rdoc.template = ENV['template'] ? "#{ENV['template']}.rb" : '../doc/template/horo'
-  rdoc.rdoc_files.include('README', 'CHANGELOG')
+  rdoc.options << '-f' << 'horo'
+  rdoc.options << '--main' << 'README.rdoc'
+  rdoc.rdoc_files.include('README.rdoc', 'CHANGELOG')
   rdoc.rdoc_files.include('lib/action_mailer.rb')
   rdoc.rdoc_files.include('lib/action_mailer/*.rb')
+  rdoc.rdoc_files.include('lib/action_mailer/delivery_method/*.rb')
 }
 
+spec = eval(File.read('actionmailer.gemspec'))
 
-# Create compressed packages
-spec = Gem::Specification.new do |s|
-  s.platform = Gem::Platform::RUBY
-  s.name = PKG_NAME
-  s.summary = "Service layer for easy email delivery and testing."
-  s.description = %q{Makes it trivial to test and deliver emails sent from a single service layer.}
-  s.version = PKG_VERSION
-
-  s.author = "David Heinemeier Hansson"
-  s.email = "david@loudthinking.com"
-  s.rubyforge_project = "actionmailer"
-  s.homepage = "http://www.rubyonrails.org"
-
-  s.add_dependency('actionpack', '= 2.3.2' + PKG_BUILD)
-
-  s.has_rdoc = true
-  s.requirements << 'none'
-  s.require_path = 'lib'
-  s.autorequire = 'action_mailer'
-
-  s.files = [ "Rakefile", "install.rb", "README", "CHANGELOG", "MIT-LICENSE" ]
-  s.files = s.files + Dir.glob( "lib/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
-  s.files = s.files + Dir.glob( "test/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
-end
-  
 Rake::GemPackageTask.new(spec) do |p|
   p.gem_spec = spec
-  p.need_tar = true
-  p.need_zip = true
 end
 
-
-desc "Publish the API documentation"
-task :pgem => [:package] do 
-  Rake::SshFilePublisher.new("gems.rubyonrails.org", "/u/sites/gems/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload
-  `ssh gems.rubyonrails.org '/u/sites/gems/gemupdate.sh'`
-end
-
-desc "Publish the API documentation"
-task :pdoc => [:rdoc] do 
-  Rake::SshDirPublisher.new("wrath.rubyonrails.org", "public_html/am", "doc").upload
-end
-
-desc "Publish the release files to RubyForge."
-task :release => [ :package ] do
-  require 'rubyforge'
-  require 'rake/contrib/rubyforgepublisher'
-
-  packages = %w( gem tgz zip ).collect{ |ext| "pkg/#{PKG_NAME}-#{PKG_VERSION}.#{ext}" }
-
-  rubyforge = RubyForge.new
-  rubyforge.login
-  rubyforge.add_release(PKG_NAME, PKG_NAME, "REL #{PKG_VERSION}", *packages)
+desc "Release to gemcutter"
+task :release => :package do
+  require 'rake/gemcutter'
+  Rake::Gemcutter::Tasks.new(spec).define
+  Rake::Task['gem:push'].invoke
 end

actionmailer/actionmailer.gemspec

@@ -0,0 +1,24 @@
+version = File.read(File.expand_path("../../RAILS_VERSION", __FILE__)).strip
+
+Gem::Specification.new do |s|
+  s.platform    = Gem::Platform::RUBY
+  s.name        = 'actionmailer'
+  s.version     = version
+  s.summary     = 'Email composition, delivery, and receiving framework (part of Rails).'
+  s.description = 'Email on Rails. Compose, deliver, receive, and test emails using the familiar controller/view pattern. First-class support for multipart email and attachments.'
+  s.required_ruby_version = '>= 1.8.7'
+
+  s.author            = 'David Heinemeier Hansson'
+  s.email             = 'david@loudthinking.com'
+  s.homepage          = 'http://www.rubyonrails.org'
+  s.rubyforge_project = 'actionmailer'
+
+  s.files        = Dir['CHANGELOG', 'README.rdoc', 'MIT-LICENSE', 'lib/**/*']
+  s.require_path = 'lib'
+  s.requirements << 'none'
+
+  s.has_rdoc = true
+
+  s.add_dependency('actionpack',  version)
+  s.add_dependency('mail',        '~> 2.2.5')
+end

actionmailer/install.rb

@@ -1,30 +0,0 @@
-require 'rbconfig'
-require 'find'
-require 'ftools'
-
-include Config
-
-# this was adapted from rdoc's install.rb by way of Log4r
-
-$sitedir = CONFIG["sitelibdir"]
-unless $sitedir
-  version = CONFIG["MAJOR"] + "." + CONFIG["MINOR"]
-  $libdir = File.join(CONFIG["libdir"], "ruby", version)
-  $sitedir = $:.find {|x| x =~ /site_ruby/ }
-  if !$sitedir
-    $sitedir = File.join($libdir, "site_ruby")
-  elsif $sitedir !~ Regexp.quote(version)
-    $sitedir = File.join($sitedir, version)
-  end
-end
-
-# the actual gruntwork
-Dir.chdir("lib")
-
-Find.find("action_mailer", "action_mailer.rb") { |f|
-  if f[-3..-1] == ".rb"
-    File::install(f, File.join($sitedir, *f.split(/\//)), 0644, true)
-  else
-    File::makedirs(File.join($sitedir, *f.split(/\//)))
-  end
-}

actionmailer/lib/action_mailer.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2004-2009 David Heinemeier Hansson
+# Copyright (c) 2004-2010 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -21,42 +21,31 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-begin
-  require 'action_controller'
-rescue LoadError
-  actionpack_path = "#{File.dirname(__FILE__)}/../../actionpack/lib"
-  if File.directory?(actionpack_path)
-    $:.unshift actionpack_path
-    require 'action_controller'
-  end
-end
+actionpack_path = File.expand_path('../../../actionpack/lib', __FILE__)
+$:.unshift(actionpack_path) if File.directory?(actionpack_path) && !$:.include?(actionpack_path)
 
+require 'abstract_controller'
 require 'action_view'
 
+# Common Active Support usage in Action Mailer
+require 'active_support/core_ext/class'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/array/uniq_by'
+require 'active_support/core_ext/module/attr_internal'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/lazy_load_hooks'
+
 module ActionMailer
-  def self.load_all!
-    [Base, Part, ::Text::Format, ::Net::SMTP]
-  end
+  extend ::ActiveSupport::Autoload
 
-  autoload :AdvAttrAccessor, 'action_mailer/adv_attr_accessor'
-  autoload :Base, 'action_mailer/base'
-  autoload :Helpers, 'action_mailer/helpers'
-  autoload :Part, 'action_mailer/part'
-  autoload :PartContainer, 'action_mailer/part_container'
-  autoload :Quoting, 'action_mailer/quoting'
-  autoload :TestCase, 'action_mailer/test_case'
-  autoload :TestHelper, 'action_mailer/test_helper'
-  autoload :Utils, 'action_mailer/utils'
+  autoload :AdvAttrAccessor
+  autoload :Collector
+  autoload :Base
+  autoload :DeliveryMethods
+  autoload :DeprecatedApi
+  autoload :MailHelper
+  autoload :OldApi
+  autoload :TestCase
+  autoload :TestHelper
 end
-
-module Text
-  autoload :Format, 'action_mailer/vendor/text_format'
-end
-
-module Net
-  autoload :SMTP, 'net/smtp'
-end
-
-autoload :MailHelper, 'action_mailer/mail_helper'
-
-require 'action_mailer/vendor/tmail'

actionmailer/lib/action_mailer/adv_attr_accessor.rb

@@ -1,29 +1,25 @@
 module ActionMailer
   module AdvAttrAccessor #:nodoc:
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
+    def adv_attr_accessor(*names)
+      names.each do |name|
+        ivar = "@#{name}"
 
-    module ClassMethods #:nodoc:
-      def adv_attr_accessor(*names)
-        names.each do |name|
-          ivar = "@#{name}"
-
-          define_method("#{name}=") do |value|
-            instance_variable_set(ivar, value)
+        class_eval <<-ACCESSORS, __FILE__, __LINE__ + 1
+          def #{name}=(value)
+            #{ivar} = value
           end
 
-          define_method(name) do |*parameters|
-            raise ArgumentError, "expected 0 or 1 parameters" unless parameters.length <= 1
-            if parameters.empty?
-              if instance_variable_names.include?(ivar)
-                instance_variable_get(ivar)
-              end
+          def #{name}(*args)
+            raise ArgumentError, "expected 0 or 1 parameters" unless args.length <= 1
+            if args.empty?
+              #{ivar} if instance_variable_names.include?(#{ivar.inspect})
             else
-              instance_variable_set(ivar, parameters.first)
+              #{ivar} = args.first
             end
           end
-        end
+        ACCESSORS
+
+        self.protected_instance_variables << ivar if self.respond_to?(:protected_instance_variables)
       end
     end
   end

actionmailer/lib/action_mailer/collector.rb

@@ -0,0 +1,30 @@
+require 'abstract_controller/collector'
+require 'active_support/core_ext/hash/reverse_merge'
+require 'active_support/core_ext/array/extract_options'
+
+module ActionMailer #:nodoc:
+  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 "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])
+      options[:body] = block_given? ? yield : @default_render.call
+      @responses << options
+    end
+  end
+end

actionmailer/lib/action_mailer/delivery_methods.rb

@@ -0,0 +1,86 @@
+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.
+  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
+
+      self.delivery_methods = {}.freeze
+      self.delivery_method  = :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 -t'
+
+      add_delivery_method :test, Mail::TestMailer
+    end
+
+    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:
+      #
+      # Example:
+      # 
+      #   add_delivery_method :sendmail, Mail::Sendmail,
+      #     :location   => '/usr/sbin/sendmail',
+      #     :arguments  => '-i -t'
+      # 
+      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) #:nodoc:
+        method ||= self.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"))
+          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

actionmailer/lib/action_mailer/deprecated_api.rb

@@ -0,0 +1,139 @@
+module ActionMailer
+  # This is the API which is deprecated and is going to be removed on Rails 3.1 release.
+  # Part of the old API will be deprecated after 3.1, for a smoother deprecation process.
+  # Check those in OldApi instead.
+  module DeprecatedApi #:nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      [:charset, :content_type, :mime_version, :implicit_parts_order].each do |method|
+        class_eval <<-FILE, __FILE__, __LINE__ + 1
+          def self.default_#{method}
+            @@default_#{method}
+          end
+
+          def self.default_#{method}=(value)
+            ActiveSupport::Deprecation.warn "ActionMailer::Base.default_#{method}=value is deprecated, " <<
+              "use default :#{method} => value instead"
+            @@default_#{method} = value
+          end
+
+          @@default_#{method} = nil
+        FILE
+      end
+    end
+
+    module ClassMethods
+      # Deliver the given mail object directly. This can be used to deliver
+      # a preconstructed mail object, like:
+      #
+      #   email = MyMailer.create_some_mail(parameters)
+      #   email.set_some_obscure_header "frobnicate"
+      #   MyMailer.deliver(email)
+      def deliver(mail, show_warning=true)
+        if show_warning
+          ActiveSupport::Deprecation.warn "#{self}.deliver is deprecated, call " <<
+            "deliver in the mailer instance instead", caller[0,2]
+        end
+
+        raise "no mail object available for delivery!" unless mail
+        wrap_delivery_behavior(mail)
+        mail.deliver
+        mail
+      end
+
+      def template_root
+        self.view_paths && self.view_paths.first
+      end
+
+      def template_root=(root)
+        ActiveSupport::Deprecation.warn "template_root= is deprecated, use prepend_view_path instead", caller[0,2]
+        self.view_paths = ActionView::Base.process_view_paths(root)
+      end
+
+      def respond_to?(method_symbol, include_private = false)
+        matches_dynamic_method?(method_symbol) || super
+      end
+
+      def method_missing(method_symbol, *parameters)
+        if match = matches_dynamic_method?(method_symbol)
+          case match[1]
+            when 'create'
+              ActiveSupport::Deprecation.warn "#{self}.create_#{match[2]} is deprecated, " <<
+                "use #{self}.#{match[2]} instead", caller[0,2]
+              new(match[2], *parameters).message
+            when 'deliver'
+              ActiveSupport::Deprecation.warn "#{self}.deliver_#{match[2]} is deprecated, " <<
+                "use #{self}.#{match[2]}.deliver instead", caller[0,2]
+              new(match[2], *parameters).message.deliver
+            else super
+          end
+        else
+          super
+        end
+      end
+
+    private
+
+      def matches_dynamic_method?(method_name)
+        method_name = method_name.to_s
+        /^(create|deliver)_([_a-z]\w*)/.match(method_name) || /^(new)$/.match(method_name)
+      end
+    end
+
+    # Delivers a Mail object. By default, it delivers the cached mail
+    # object (from the <tt>create!</tt> method). If no cached mail object exists, and
+    # no alternate has been given as the parameter, this will fail.
+    def deliver!(mail = @_message)
+      ActiveSupport::Deprecation.warn "Calling deliver in the AM::Base object is deprecated, " <<
+        "please call deliver in the Mail instance", caller[0,2]
+      self.class.deliver(mail, false)
+    end
+    alias :deliver :deliver!
+
+    def render(*args)
+      options = args.last.is_a?(Hash) ? args.last : {}
+
+      if options[:body].is_a?(Hash)
+        ActiveSupport::Deprecation.warn(':body in render deprecated. Please use instance ' <<
+                                        'variables as assigns instead', caller[0,1])
+
+        options[:body].each { |k,v| instance_variable_set(:"@#{k}", v) }
+      end
+      super
+    end
+
+    # Render a message but does not set it as mail body. Useful for rendering
+    # data for part and attachments.
+    #
+    # Examples:
+    #
+    #   render_message "special_message"
+    #   render_message :template => "special_message"
+    #   render_message :inline => "<%= 'Hi!' %>"
+    #
+    def render_message(*args)
+      ActiveSupport::Deprecation.warn "render_message is deprecated, use render instead", caller[0,2]
+      render(*args)
+    end
+
+  private
+
+    def initialize_defaults(*)
+      @charset              ||= self.class.default_charset.try(:dup)
+      @content_type         ||= self.class.default_content_type.try(:dup)
+      @implicit_parts_order ||= self.class.default_implicit_parts_order.try(:dup)
+      @mime_version         ||= self.class.default_mime_version.try(:dup)
+      super
+    end
+
+    def create_parts
+      if @body.is_a?(Hash) && !@body.empty?
+        ActiveSupport::Deprecation.warn "Giving a hash to body is deprecated, please use instance variables instead", caller[0,2]
+        @body.each { |k, v| instance_variable_set(:"@#{k}", v) }
+      end
+      super
+    end
+
+  end
+end

actionmailer/lib/action_mailer/helpers.rb

@@ -1,113 +0,0 @@
-require 'active_support/dependencies'
-
-module ActionMailer
-  module Helpers #:nodoc:
-    def self.included(base) #:nodoc:
-      # Initialize the base module to aggregate its helpers.
-      base.class_inheritable_accessor :master_helper_module
-      base.master_helper_module = Module.new
-
-      # Extend base with class methods to declare helpers.
-      base.extend(ClassMethods)
-
-      base.class_eval do
-        # Wrap inherited to create a new master helper module for subclasses.
-        class << self
-          alias_method_chain :inherited, :helper
-        end
-
-        # Wrap initialize_template_class to extend new template class
-        # instances with the master helper module.
-        alias_method_chain :initialize_template_class, :helper
-      end
-    end
-
-    module ClassMethods
-      # Makes all the (instance) methods in the helper module available to templates rendered through this controller.
-      # See ActionView::Helpers (link:classes/ActionView/Helpers.html) for more about making your own helper modules
-      # available to the templates.
-      def add_template_helper(helper_module) #:nodoc:
-        master_helper_module.module_eval "include #{helper_module}"
-      end
-
-      # Declare a helper:
-      #   helper :foo
-      # requires 'foo_helper' and includes FooHelper in the template class.
-      #   helper FooHelper
-      # includes FooHelper in the template class.
-      #   helper { def foo() "#{bar} is the very best" end }
-      # evaluates the block in the template class, adding method +foo+.
-      #   helper(:three, BlindHelper) { def mice() 'mice' end }
-      # does all three.
-      def helper(*args, &block)
-        args.flatten.each do |arg|
-          case arg
-            when Module
-              add_template_helper(arg)
-            when String, Symbol
-              file_name  = arg.to_s.underscore + '_helper'
-              class_name = file_name.camelize
-
-              begin
-                require_dependency(file_name)
-              rescue LoadError => load_error
-                requiree = / -- (.*?)(\.rb)?$/.match(load_error.message).to_a[1]
-                msg = (requiree == file_name) ? "Missing helper file helpers/#{file_name}.rb" : "Can't load file: #{requiree}"
-                raise LoadError.new(msg).copy_blame!(load_error)
-              end
-
-              add_template_helper(class_name.constantize)
-            else
-              raise ArgumentError, 'helper expects String, Symbol, or Module argument'
-          end
-        end
-
-        # Evaluate block in template class if given.
-        master_helper_module.module_eval(&block) if block_given?
-      end
-
-      # Declare a controller method as a helper.  For example,
-      #   helper_method :link_to
-      #   def link_to(name, options) ... end
-      # makes the link_to controller method available in the view.
-      def helper_method(*methods)
-        methods.flatten.each do |method|
-          master_helper_module.module_eval <<-end_eval
-            def #{method}(*args, &block)
-              controller.__send__(%(#{method}), *args, &block)
-            end
-          end_eval
-        end
-      end
-
-      # Declare a controller attribute as a helper.  For example,
-      #   helper_attr :name
-      #   attr_accessor :name
-      # makes the name and name= controller methods available in the view.
-      # The is a convenience wrapper for helper_method.
-      def helper_attr(*attrs)
-        attrs.flatten.each { |attr| helper_method(attr, "#{attr}=") }
-      end
-
-      private
-        def inherited_with_helper(child)
-          inherited_without_helper(child)
-          begin
-            child.master_helper_module = Module.new
-            child.master_helper_module.__send__(:include, master_helper_module)
-            child.helper child.name.to_s.underscore
-          rescue MissingSourceFile => e
-            raise unless e.is_missing?("helpers/#{child.name.to_s.underscore}_helper")
-          end
-        end
-    end
-
-    private
-      # Extend the template class instance with our controller's helper module.
-      def initialize_template_class_with_helper(assigns)
-        returning(template = initialize_template_class_without_helper(assigns)) do
-          template.extend self.class.master_helper_module
-        end
-      end
-  end
-end

actionmailer/lib/action_mailer/log_subscriber.rb

@@ -0,0 +1,22 @@
+require 'active_support/core_ext/array/wrap'
+
+module ActionMailer
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def deliver(event)
+      recipients = Array.wrap(event.payload[:to]).join(', ')
+      info("\nSent mail to #{recipients} (%1.fms)" % event.duration)
+      debug(event.payload[:mail])
+    end
+
+    def receive(event)
+      info("\nReceived mail (%.1fms)" % event.duration)
+      debug(event.payload[:mail])
+    end
+
+    def logger
+      ActionMailer::Base.logger
+    end
+  end
+end
+
+ActionMailer::LogSubscriber.attach_to :action_mailer

actionmailer/lib/action_mailer/mail_helper.rb

@@ -1,17 +1,41 @@
-module MailHelper
-  # Uses Text::Format to take the text and format it, indented two spaces for
-  # each line, and wrapped at 72 columns.
-  def block_format(text)
-    formatted = text.split(/\n\r\n/).collect { |paragraph| 
-      Text::Format.new(
-        :columns => 72, :first_indent => 2, :body_indent => 2, :text => paragraph
-      ).format
-    }.join("\n")
-    
-    # Make list points stand on their own line
-    formatted.gsub!(/[ ]*([*]+) ([^*]*)/) { |s| "  #{$1} #{$2.strip}\n" }
-    formatted.gsub!(/[ ]*([#]+) ([^#]*)/) { |s| "  #{$1} #{$2.strip}\n" }
+module ActionMailer
+  module MailHelper
+    # Uses Text::Format to take the text and format it, indented two spaces for
+    # each line, and wrapped at 72 columns.
+    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
+      formatted = text.split(/\n\r\n/).collect { |paragraph|
+        Text::Format.new(
+          :columns => 72, :first_indent => 2, :body_indent => 2, :text => paragraph
+        ).format
+      }.join("\n")
+    
+      # Make list points stand on their own line
+      formatted.gsub!(/[ ]*([*]+) ([^*]*)/) { |s| "  #{$1} #{$2.strip}\n" }
+      formatted.gsub!(/[ ]*([#]+) ([^#]*)/) { |s| "  #{$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
+      @_message.attachments
+    end
   end
 end

actionmailer/lib/action_mailer/old_api.rb

@@ -0,0 +1,259 @@
+require 'active_support/concern'
+require 'active_support/core_ext/object/try'
+require 'active_support/core_ext/object/blank'
+
+module ActionMailer
+  module OldApi #:nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      extend ActionMailer::AdvAttrAccessor
+
+      @@protected_instance_variables = %w(@parts)
+      cattr_reader :protected_instance_variables
+
+      # Specify the BCC addresses for the message
+      adv_attr_accessor :bcc
+
+      # Specify the CC addresses for the message.
+      adv_attr_accessor :cc
+
+      # Specify the charset to use for the message. This defaults to the
+      # +default_charset+ specified for ActionMailer::Base.
+      adv_attr_accessor :charset
+
+      # Specify the content type for the message. This defaults to <tt>text/plain</tt>
+      # in most cases, but can be automatically set in some situations.
+      adv_attr_accessor :content_type
+
+      # Specify the from address for the message.
+      adv_attr_accessor :from
+
+      # Specify the address (if different than the "from" address) to direct
+      # replies to this message.
+      adv_attr_accessor :reply_to
+
+      # Specify the order in which parts should be sorted, based on content-type.
+      # This defaults to the value for the +default_implicit_parts_order+.
+      adv_attr_accessor :implicit_parts_order
+
+      # Defaults to "1.0", but may be explicitly given if needed.
+      adv_attr_accessor :mime_version
+
+      # The recipient addresses for the message, either as a string (for a single
+      # address) or an array (for multiple addresses).
+      adv_attr_accessor :recipients
+
+      # The date on which the message was sent. If not set (the default), the
+      # header will be set by the delivery agent.
+      adv_attr_accessor :sent_on
+
+      # Specify the subject of the message.
+      adv_attr_accessor :subject
+
+      # Specify the template name to use for current message. This is the "base"
+      # template name, without the extension or directory, and may be used to
+      # have multiple mailer methods share the same template.
+      adv_attr_accessor :template
+
+      # Override the mailer name, which defaults to an inflected version of the
+      # mailer's class name. If you want to use a template in a non-standard
+      # location, you can use this to specify that location.
+      adv_attr_accessor :mailer_name
+
+      # Define the body of the message. This is either a Hash (in which case it
+      # specifies the variables to pass to the template when it is rendered),
+      # or a string, in which case it specifies the actual text of the message.
+      adv_attr_accessor :body
+
+      # Alias controller_path to mailer_name so render :partial in views work.
+      alias :controller_path :mailer_name
+    end
+
+    def process(method_name, *args)
+      initialize_defaults(method_name)
+      super
+      unless @mail_was_called
+        create_parts
+        create_mail
+      end
+      @_message
+    end
+
+    # Add a part to a multipart message, with the given content-type. The
+    # part itself is yielded to the block so that other properties (charset,
+    # body, headers, etc.) can be set on it.
+    def part(params)
+      params = {:content_type => params} if String === params
+
+      if custom_headers = params.delete(:headers)
+        params.merge!(custom_headers)
+      end
+
+      part = Mail::Part.new(params)
+
+      yield part if block_given?
+      @parts << part
+    end
+
+    # Add an attachment to a multipart message. This is simply a part with the
+    # content-disposition set to "attachment".
+    def attachment(params, &block)
+      params = { :content_type => params } if String === params
+
+      params[:content] ||= params.delete(:data) || params.delete(:body)
+
+      if params[:filename]
+        params = normalize_file_hash(params)
+      else
+        params = normalize_nonfile_hash(params)
+      end
+
+      part(params, &block)
+    end
+
+  protected
+
+    def normalize_nonfile_hash(params)
+      content_disposition = "attachment;"
+      
+      mime_type = params.delete(:mime_type)
+      
+      if content_type = params.delete(:content_type)
+        content_type = "#{mime_type || content_type};"
+      end
+
+      params[:body] = params.delete(:data) if params[:data]
+      
+      { :content_type => content_type,
+        :content_disposition => content_disposition }.merge(params)
+    end
+    
+    def normalize_file_hash(params)
+      filename = File.basename(params.delete(:filename))
+      content_disposition = "attachment; filename=\"#{File.basename(filename)}\""
+      
+      mime_type = params.delete(:mime_type)
+      
+      if (content_type = params.delete(:content_type)) && (content_type !~ /filename=/)
+        content_type = "#{mime_type || content_type}; filename=\"#{filename}\""
+      end
+      
+      params[:body] = params.delete(:data) if params[:data]
+      
+      { :content_type => content_type,
+        :content_disposition => content_disposition }.merge(params)
+    end
+
+    def create_mail 
+      m = @_message
+
+      set_fields!({:subject => subject, :to => recipients, :from => from,
+                   :bcc => bcc, :cc => cc, :reply_to => reply_to}, charset)
+
+      m.mime_version = mime_version    unless mime_version.nil?
+      m.date         = sent_on.to_time rescue sent_on if sent_on
+
+      @headers.each { |k, v| m[k] = v }
+
+      real_content_type, ctype_attrs = parse_content_type
+      main_type, sub_type = split_content_type(real_content_type)
+
+      if @parts.size == 1 && @parts.first.parts.empty?
+        m.content_type([main_type, sub_type, ctype_attrs])
+        m.body = @parts.first.body.encoded
+      else
+        @parts.each do |p|
+          m.add_part(p)
+        end
+
+        m.body.set_sort_order(@implicit_parts_order)
+        m.body.sort_parts!
+
+        if real_content_type =~ /multipart/
+          ctype_attrs.delete "charset"
+          m.content_type([main_type, sub_type, ctype_attrs])
+        end
+      end
+
+      wrap_delivery_behavior!
+      m.content_transfer_encoding = '8bit' unless m.body.only_us_ascii?
+      
+      @_message
+    end
+    
+    # Set up the default values for the various instance variables of this
+    # mailer. Subclasses may override this method to provide different
+    # defaults.
+    def initialize_defaults(method_name) 
+      @charset              ||= self.class.default[:charset].try(:dup)
+      @content_type         ||= self.class.default[:content_type].try(:dup)
+      @implicit_parts_order ||= self.class.default[:parts_order].try(:dup)
+      @mime_version         ||= self.class.default[:mime_version].try(:dup)
+
+      @mailer_name   ||= self.class.mailer_name.dup
+      @template      ||= method_name
+      @mail_was_called = false
+
+      @parts   ||= []
+      @headers ||= {}
+      @sent_on ||= Time.now
+      @body ||= {}
+    end
+
+    def create_parts 
+      if String === @body
+        @parts.unshift create_inline_part(@body)
+      elsif @parts.empty? || @parts.all? { |p| p.content_disposition =~ /^attachment/ }
+        lookup_context.find_all(@template, @mailer_name).each do |template|
+          self.formats = template.formats
+          @parts << create_inline_part(render(:template => template), template.mime_type)
+        end
+
+        if @parts.size > 1
+          @content_type = "multipart/alternative" if @content_type !~ /^multipart/
+        end
+
+        # If this is a multipart e-mail add the mime_version if it is not
+        # already set.
+        @mime_version ||= "1.0" if !@parts.empty?
+      end
+    end
+
+    def create_inline_part(body, mime_type=nil) 
+      ct = mime_type || "text/plain"
+      main_type, sub_type = split_content_type(ct.to_s)
+
+      Mail::Part.new(
+        :content_type => [main_type, sub_type, {:charset => charset}],
+        :content_disposition => "inline",
+        :body => body
+      )
+    end
+
+    def set_fields!(headers, charset) #:nodoc:
+      m = @_message
+      m.charset = charset
+      m.subject  ||= headers.delete(:subject)  if headers[:subject]
+      m.to       ||= headers.delete(:to)       if headers[:to]
+      m.from     ||= headers.delete(:from)     if headers[:from]
+      m.cc       ||= headers.delete(:cc)       if headers[:cc]
+      m.bcc      ||= headers.delete(:bcc)      if headers[:bcc]
+      m.reply_to ||= headers.delete(:reply_to) if headers[:reply_to]
+    end
+
+    def split_content_type(ct) 
+      ct.to_s.split("/")
+    end
+
+    def parse_content_type(defaults=nil) 
+      if @content_type.blank?
+        [ nil, {} ]
+      else
+        ctype, *attrs = @content_type.split(/;\s*/)
+        attrs = attrs.inject({}) { |h,s| k,v = s.split(/\=/, 2); h[k] = v; h }
+        [ctype, {"charset" => @charset}.merge(attrs)]
+      end
+    end
+  end
+end

actionmailer/lib/action_mailer/part.rb

@@ -1,107 +0,0 @@
-module ActionMailer
-  # Represents a subpart of an email message. It shares many similar
-  # attributes of ActionMailer::Base.  Although you can create parts manually
-  # and add them to the +parts+ list of the mailer, it is easier
-  # to use the helper methods in ActionMailer::PartContainer.
-  class Part
-    include AdvAttrAccessor, PartContainer, Utils
-
-    # Represents the body of the part, as a string. This should not be a
-    # Hash (like ActionMailer::Base), but if you want a template to be rendered
-    # into the body of a subpart you can do it with the mailer's +render+ method
-    # and assign the result here.
-    adv_attr_accessor :body
-    
-    # Specify the charset for this subpart. By default, it will be the charset
-    # of the containing part or mailer.
-    adv_attr_accessor :charset
-    
-    # The content disposition of this part, typically either "inline" or
-    # "attachment".
-    adv_attr_accessor :content_disposition
-    
-    # The content type of the part.
-    adv_attr_accessor :content_type
-    
-    # The filename to use for this subpart (usually for attachments).
-    adv_attr_accessor :filename
-    
-    # Accessor for specifying additional headers to include with this part.
-    adv_attr_accessor :headers
-    
-    # The transfer encoding to use for this subpart, like "base64" or
-    # "quoted-printable".
-    adv_attr_accessor :transfer_encoding
-
-    # Create a new part from the given +params+ hash. The valid params keys
-    # correspond to the accessors.
-    def initialize(params)
-      @content_type = params[:content_type]
-      @content_disposition = params[:disposition] || "inline"
-      @charset = params[:charset]
-      @body = params[:body]
-      @filename = params[:filename]
-      @transfer_encoding = params[:transfer_encoding] || "quoted-printable"
-      @headers = params[:headers] || {}
-      @parts = []
-    end
-
-    # Convert the part to a mail object which can be included in the parts
-    # list of another mail object.
-    def to_mail(defaults)
-      part = TMail::Mail.new
-
-      real_content_type, ctype_attrs = parse_content_type(defaults)
-
-      if @parts.empty?
-        part.content_transfer_encoding = transfer_encoding || "quoted-printable"
-        case (transfer_encoding || "").downcase
-          when "base64" then
-            part.body = TMail::Base64.folding_encode(body)
-          when "quoted-printable"
-            part.body = [normalize_new_lines(body)].pack("M*")
-          else
-            part.body = body
-        end
-
-        # Always set the content_type after setting the body and or parts!
-        # Also don't set filename and name when there is none (like in
-        # non-attachment parts)
-        if content_disposition == "attachment"
-          ctype_attrs.delete "charset"
-          part.set_content_type(real_content_type, nil,
-            squish("name" => filename).merge(ctype_attrs))
-          part.set_content_disposition(content_disposition,
-            squish("filename" => filename).merge(ctype_attrs))
-        else
-          part.set_content_type(real_content_type, nil, ctype_attrs)
-          part.set_content_disposition(content_disposition) 
-        end        
-      else
-        if String === body
-          @parts.unshift Part.new(:charset => charset, :body => @body, :content_type => 'text/plain')
-          @body = nil
-        end
-          
-        @parts.each do |p|
-          prt = (TMail::Mail === p ? p : p.to_mail(defaults))
-          part.parts << prt
-        end
-        
-        if real_content_type =~ /multipart/
-          ctype_attrs.delete 'charset'
-          part.set_content_type(real_content_type, nil, ctype_attrs)
-        end
-      end
-
-      headers.each { |k,v| part[k] = v }
-
-      part
-    end
-
-    private
-      def squish(values={})
-        values.delete_if { |k,v| v.nil? }
-      end
-  end
-end

actionmailer/lib/action_mailer/part_container.rb

@@ -1,55 +0,0 @@
-module ActionMailer
-  # Accessors and helpers that ActionMailer::Base and ActionMailer::Part have
-  # in common. Using these helpers you can easily add subparts or attachments
-  # to your message:
-  #
-  #   def my_mail_message(...)
-  #     ...
-  #     part "text/plain" do |p|
-  #       p.body "hello, world"
-  #       p.transfer_encoding "base64"
-  #     end
-  #
-  #     attachment "image/jpg" do |a|
-  #       a.body = File.read("hello.jpg")
-  #       a.filename = "hello.jpg"
-  #     end
-  #   end
-  module PartContainer
-    # The list of subparts of this container
-    attr_reader :parts
-
-    # Add a part to a multipart message, with the given content-type. The
-    # part itself is yielded to the block so that other properties (charset,
-    # body, headers, etc.) can be set on it.
-    def part(params)
-      params = {:content_type => params} if String === params
-      part = Part.new(params)
-      yield part if block_given?
-      @parts << part
-    end
-
-    # Add an attachment to a multipart message. This is simply a part with the
-    # content-disposition set to "attachment".
-    def attachment(params, &block)
-      params = { :content_type => params } if String === params
-      params = { :disposition => "attachment",
-                 :transfer_encoding => "base64" }.merge(params)
-      part(params, &block)
-    end
-
-    private
-    
-      def parse_content_type(defaults=nil)
-        if content_type.blank? 
-          return defaults                                                ? 
-            [ defaults.content_type, { 'charset' => defaults.charset } ] : 
-            [ nil, {} ] 
-        end 
-        ctype, *attrs = content_type.split(/;\s*/)
-        attrs = attrs.inject({}) { |h,s| k,v = s.split(/=/, 2); h[k] = v; h }
-        [ctype, {"charset" => charset || defaults && defaults.charset}.merge(attrs)]
-      end
-
-  end
-end

actionmailer/lib/action_mailer/quoting.rb

@@ -1,61 +0,0 @@
-module ActionMailer
-  module Quoting #:nodoc:
-    # Convert the given text into quoted printable format, with an instruction
-    # that the text be eventually interpreted in the given charset.
-    def quoted_printable(text, charset)
-      text = text.gsub( /[^a-z ]/i ) { quoted_printable_encode($&) }.
-                  gsub( / /, "_" )
-      "=?#{charset}?Q?#{text}?="
-    end
-
-    # Convert the given character to quoted printable format, taking into
-    # account multi-byte characters (if executing with $KCODE="u", for instance)
-    def quoted_printable_encode(character)
-      result = ""
-      character.each_byte { |b| result << "=%02X" % b }
-      result
-    end
-
-    # A quick-and-dirty regexp for determining whether a string contains any
-    # characters that need escaping.
-    if !defined?(CHARS_NEEDING_QUOTING)
-      CHARS_NEEDING_QUOTING = /[\000-\011\013\014\016-\037\177-\377]/
-    end
-
-    # Quote the given text if it contains any "illegal" characters
-    def quote_if_necessary(text, charset)
-      text = text.dup.force_encoding(Encoding::ASCII_8BIT) if text.respond_to?(:force_encoding)
-
-      (text =~ CHARS_NEEDING_QUOTING) ?
-        quoted_printable(text, charset) :
-        text
-    end
-
-    # Quote any of the given strings if they contain any "illegal" characters
-    def quote_any_if_necessary(charset, *args)
-      args.map { |v| quote_if_necessary(v, charset) }
-    end
-
-    # Quote the given address if it needs to be. The address may be a
-    # regular email address, or it can be a phrase followed by an address in
-    # brackets. The phrase is the only part that will be quoted, and only if
-    # it needs to be. This allows extended characters to be used in the
-    # "to", "from", "cc", "bcc" and "reply-to" headers.
-    def quote_address_if_necessary(address, charset)
-      if Array === address
-        address.map { |a| quote_address_if_necessary(a, charset) }
-      elsif address =~ /^(\S.*)\s+(<.*>)$/
-        address = $2
-        phrase = quote_if_necessary($1.gsub(/^['"](.*)['"]$/, '\1'), charset)
-        "\"#{phrase}\" #{address}"
-      else
-        address
-      end
-    end
-
-    # Quote any of the given addresses, if they need to be.
-    def quote_any_address_if_necessary(charset, *args)
-      args.map { |v| quote_address_if_necessary(v, charset) }
-    end
-  end
-end

actionmailer/lib/action_mailer/railtie.rb

@@ -0,0 +1,26 @@
+require "action_mailer"
+require "rails"
+
+module ActionMailer
+  class Railtie < Rails::Railtie
+    config.action_mailer = ActiveSupport::OrderedOptions.new
+
+    initializer "action_mailer.logger" do
+      ActiveSupport.on_load(:action_mailer) { self.logger ||= Rails.logger }
+    end
+
+    initializer "action_mailer.set_configs" do |app|
+      paths   = app.config.paths
+      options = app.config.action_mailer
+
+      options.assets_dir      ||= paths.public.to_a.first
+      options.javascripts_dir ||= paths.public.javascripts.to_a.first
+      options.stylesheets_dir ||= paths.public.stylesheets.to_a.first
+
+      ActiveSupport.on_load(:action_mailer) do
+        include app.routes.url_helpers
+        options.each { |k,v| send("#{k}=", v) }
+      end
+    end
+  end
+end

actionmailer/lib/action_mailer/test_case.rb

@@ -1,5 +1,3 @@
-require 'active_support/test_case'
-
 module ActionMailer
   class NonInferrableMailerError < ::StandardError
     def initialize(name)
@@ -10,55 +8,69 @@ module ActionMailer
   end
 
   class TestCase < ActiveSupport::TestCase
-    include Quoting, TestHelper
+    module Behavior
+      extend ActiveSupport::Concern
 
-    setup :initialize_test_deliveries
-    setup :set_expected_mail
+      include TestHelper
 
-    class << self
-      def tests(mailer)
-        write_inheritable_attribute(:mailer_class, mailer)
-      end
+      module ClassMethods
+        def tests(mailer)
+          write_inheritable_attribute(:mailer_class, mailer)
+        end
 
-      def mailer_class
-        if mailer = read_inheritable_attribute(:mailer_class)
-          mailer
-        else
-          tests determine_default_mailer(name)
+        def mailer_class
+          if mailer = read_inheritable_attribute(:mailer_class)
+            mailer
+          else
+            tests determine_default_mailer(name)
+          end
+        end
+
+        def determine_default_mailer(name)
+          name.sub(/Test$/, '').constantize
+        rescue NameError
+          raise NonInferrableMailerError.new(name)
         end
       end
 
-      def determine_default_mailer(name)
-        name.sub(/Test$/, '').constantize
-      rescue NameError => e
-        raise NonInferrableMailerError.new(name)
+      module InstanceMethods
+
+      protected
+
+        def initialize_test_deliveries
+          ActionMailer::Base.delivery_method = :test
+          ActionMailer::Base.perform_deliveries = true
+          ActionMailer::Base.deliveries.clear
+        end
+
+        def set_expected_mail
+          @expected = Mail.new
+          @expected.content_type ["text", "plain", { "charset" => charset }]
+          @expected.mime_version = '1.0'
+        end
+
+      private
+
+        def charset
+          "UTF-8"
+        end
+
+        def encode(subject)
+          Mail::Encodings.q_value_encode(subject, charset)
+        end
+
+        def read_fixture(action)
+          IO.readlines(File.join(Rails.root, 'test', 'fixtures', self.class.mailer_class.name.underscore, action))
+        end
+      end
+
+      included do
+        setup :initialize_test_deliveries
+        setup :set_expected_mail
       end
     end
 
-    protected
-      def initialize_test_deliveries
-        ActionMailer::Base.delivery_method = :test
-        ActionMailer::Base.perform_deliveries = true
-        ActionMailer::Base.deliveries = []
-      end
+    include Behavior
 
-      def set_expected_mail
-        @expected = TMail::Mail.new
-        @expected.set_content_type "text", "plain", { "charset" => charset }
-        @expected.mime_version = '1.0'
-      end
-
-    private
-      def charset
-        "utf-8"
-      end
-
-      def encode(subject)
-        quoted_printable(subject, charset)
-      end
-
-      def read_fixture(action)
-        IO.readlines(File.join(RAILS_ROOT, 'test', 'fixtures', self.class.mailer_class.name.underscore, action))
-      end
   end
 end

actionmailer/lib/action_mailer/test_helper.rb

@@ -1,5 +1,7 @@
 module ActionMailer
   module TestHelper
+    extend ActiveSupport::Concern
+
     # Asserts that the number of emails sent matches the given number.
     #
     #   def test_emails
@@ -57,12 +59,3 @@ module ActionMailer
     end
   end
 end
-
-# TODO: Deprecate this
-module Test
-  module Unit
-    class TestCase
-      include ActionMailer::TestHelper
-    end
-  end
-end

actionmailer/lib/action_mailer/tmail_compat.rb

@@ -0,0 +1,34 @@
+module Mail
+  class Message
+    
+    def set_content_type(*args)
+      ActiveSupport::Deprecation.warn('Message#set_content_type is deprecated, please just call ' <<
+                                      'Message#content_type with the same arguments', caller[0,2])
+      content_type(*args)
+    end
+    
+    alias :old_transfer_encoding :transfer_encoding
+    def transfer_encoding(value = nil)
+      if value
+        ActiveSupport::Deprecation.warn('Message#transfer_encoding is deprecated, please call ' <<
+                                        'Message#content_transfer_encoding with the same arguments', caller[0,2])
+        content_transfer_encoding(value)
+      else
+        old_transfer_encoding
+      end
+    end
+
+    def transfer_encoding=(value)
+      ActiveSupport::Deprecation.warn('Message#transfer_encoding= is deprecated, please call ' <<
+                                      'Message#content_transfer_encoding= with the same arguments', caller[0,2])
+      self.content_transfer_encoding = value
+    end
+
+    def original_filename
+      ActiveSupport::Deprecation.warn('Message#original_filename is deprecated, ' <<
+                                      'please call Message#filename', caller[0,2])
+      filename
+    end
+    
+  end
+end

actionmailer/lib/action_mailer/utils.rb

@@ -1,7 +0,0 @@
-module ActionMailer
-  module Utils #:nodoc:
-    def normalize_new_lines(text)
-      text.to_s.gsub(/\r\n?/, "\n")
-    end
-  end
-end

actionmailer/lib/action_mailer/vendor/text_format.rb

@@ -1,10 +0,0 @@
-# Prefer gems to the bundled libs.
-require 'rubygems'
-
-begin
-  gem 'text-format', '>= 0.6.3'
-rescue Gem::LoadError
-  $:.unshift "#{File.dirname(__FILE__)}/text-format-0.6.3"
-end
-
-require 'text/format'

actionmailer/lib/action_mailer/vendor/tmail-1.2.3/tmail.rb

@@ -1,5 +0,0 @@
-require 'tmail/version'
-require 'tmail/mail'
-require 'tmail/mailbox'
-require 'tmail/core_extensions'
-require 'tmail/net'

actionmailer/lib/action_mailer/vendor/tmail-1.2.3/tmail/address.rb

@@ -1,426 +0,0 @@
-=begin rdoc
-
-= Address handling class
-
-=end
-#--
-# Copyright (c) 1998-2003 Minero Aoki <aamine@loveruby.net>
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-# Note: Originally licensed under LGPL v2+. Using MIT license for Rails
-# with permission of Minero Aoki.
-#++
-
-require 'tmail/encode'
-require 'tmail/parser'
-
-
-module TMail
-
-  # = Class Address
-  # 
-  # Provides a complete handling library for email addresses. Can parse a string of an
-  # address directly or take in preformatted addresses themselves.  Allows you to add
-  # and remove phrases from the front of the address and provides a compare function for
-  # email addresses.
-  # 
-  # == Parsing and Handling a Valid Address:
-  # 
-  # Just pass the email address in as a string to Address.parse:
-  # 
-  #  email = TMail::Address.parse('Mikel Lindsaar <mikel@lindsaar.net>)
-  #  #=> #<TMail::Address mikel@lindsaar.net>
-  #  email.address
-  #  #=> "mikel@lindsaar.net"
-  #  email.local
-  #  #=> "mikel"
-  #  email.domain
-  #  #=> "lindsaar.net"
-  #  email.name             # Aliased as phrase as well
-  #  #=> "Mikel Lindsaar"
-  # 
-  # == Detecting an Invalid Address
-  # 
-  # If you want to check the syntactical validity of an email address, just pass it to
-  # Address.parse and catch any SyntaxError:
-  # 
-  #  begin
-  #    TMail::Mail.parse("mikel   2@@@@@ me .com")
-  #  rescue TMail::SyntaxError
-  #    puts("Invalid Email Address Detected")
-  #  else
-  #    puts("Address is valid")
-  #  end
-  #  #=> "Invalid Email Address Detected"
-  class Address
-
-    include TextUtils #:nodoc:
-    
-    # Sometimes you need to parse an address, TMail can do it for you and provide you with
-    # a fairly robust method of detecting a valid address.
-    # 
-    # Takes in a string, returns a TMail::Address object.
-    # 
-    # Raises a TMail::SyntaxError on invalid email format
-    def Address.parse( str )
-      Parser.parse :ADDRESS, special_quote_address(str)
-    end
-    
-    def Address.special_quote_address(str) #:nodoc:
-      # Takes a string which is an address and adds quotation marks to special
-      # edge case methods that the RACC parser can not handle.
-      #
-      # Right now just handles two edge cases:
-      #
-      # Full stop as the last character of the display name:
-      #   Mikel L. <mikel@me.com>
-      # Returns:
-      #   "Mikel L." <mikel@me.com>
-      #
-      # Unquoted @ symbol in the display name:
-      #   mikel@me.com <mikel@me.com>
-      # Returns:
-      #   "mikel@me.com" <mikel@me.com>
-      #
-      # Any other address not matching these patterns just gets returned as is. 
-      case
-      # This handles the missing "" in an older version of Apple Mail.app
-      # around the display name when the display name contains a '@'
-      # like 'mikel@me.com <mikel@me.com>'
-      # Just quotes it to: '"mikel@me.com" <mikel@me.com>'
-      when str =~ /\A([^"].+@.+[^"])\s(<.*?>)\Z/
-        return "\"#{$1}\" #{$2}"
-      # This handles cases where 'Mikel A. <mikel@me.com>' which is a trailing
-      # full stop before the address section.  Just quotes it to
-      # '"Mikel A. <mikel@me.com>"
-      when str =~ /\A(.*?\.)\s(<.*?>)\Z/
-        return "\"#{$1}\" #{$2}"
-      else
-        str
-      end
-    end
-
-    def address_group? #:nodoc:
-      false
-    end
-
-    # Address.new(local, domain)
-    # 
-    # Accepts:
-    # 
-    # * local - Left of the at symbol
-    # 
-    # * domain - Array of the domain split at the periods.
-    # 
-    # For example:
-    # 
-    #  Address.new("mikel", ["lindsaar", "net"])
-    #  #=> "#<TMail::Address mikel@lindsaar.net>"
-    def initialize( local, domain )
-      if domain
-        domain.each do |s|
-          raise SyntaxError, 'empty word in domain' if s.empty?
-        end
-      end
-      
-      # This is to catch an unquoted "@" symbol in the local part of the
-      # address.  Handles addresses like <"@"@me.com> and makes sure they
-      # stay like <"@"@me.com> (previously were becoming <@@me.com>)
-      if local && (local.join == '@' || local.join =~ /\A[^"].*?@.*?[^"]\Z/)
-        @local = "\"#{local.join}\""
-      else
-        @local = local
-      end
-
-      @domain = domain
-      @name   = nil
-      @routes = []
-    end
-
-    # Provides the name or 'phrase' of the email address.
-    # 
-    # For Example:
-    # 
-    #  email = TMail::Address.parse("Mikel Lindsaar <mikel@lindsaar.net>")
-    #  email.name
-    #  #=> "Mikel Lindsaar"
-    def name
-      @name
-    end
-
-    # Setter method for the name or phrase of the email
-    # 
-    # For Example:
-    # 
-    #  email = TMail::Address.parse("mikel@lindsaar.net")
-    #  email.name
-    #  #=> nil
-    #  email.name = "Mikel Lindsaar"
-    #  email.to_s
-    #  #=> "Mikel Lindsaar <mikel@me.com>"
-    def name=( str )
-      @name = str
-      @name = nil if str and str.empty?
-    end
-
-    #:stopdoc:
-    alias phrase  name
-    alias phrase= name=
-    #:startdoc:
-    
-    # This is still here from RFC 822, and is now obsolete per RFC2822 Section 4.
-    # 
-    # "When interpreting addresses, the route portion SHOULD be ignored."
-    # 
-    # It is still here, so you can access it.
-    # 
-    # Routes return the route portion at the front of the email address, if any.
-    # 
-    # For Example:
-    #  email = TMail::Address.parse( "<@sa,@another:Mikel@me.com>")
-    #  => #<TMail::Address Mikel@me.com>
-    #  email.to_s
-    #  => "<@sa,@another:Mikel@me.com>"
-    #  email.routes
-    #  => ["sa", "another"]
-    def routes
-      @routes
-    end
-    
-    def inspect #:nodoc:
-      "#<#{self.class} #{address()}>"
-    end
-
-    # Returns the local part of the email address
-    # 
-    # For Example:
-    # 
-    #  email = TMail::Address.parse("mikel@lindsaar.net")
-    #  email.local
-    #  #=> "mikel"
-    def local
-      return nil unless @local
-      return '""' if @local.size == 1 and @local[0].empty?
-      # Check to see if it is an array before trying to map it
-      if @local.respond_to?(:map)
-        @local.map {|i| quote_atom(i) }.join('.')
-      else
-        quote_atom(@local)
-      end
-    end
-
-    # Returns the domain part of the email address
-    # 
-    # For Example:
-    # 
-    #  email = TMail::Address.parse("mikel@lindsaar.net")
-    #  email.local
-    #  #=> "lindsaar.net"
-    def domain
-      return nil unless @domain
-      join_domain(@domain)
-    end
-
-    # Returns the full specific address itself
-    # 
-    # For Example:
-    # 
-    #  email = TMail::Address.parse("mikel@lindsaar.net")
-    #  email.address
-    #  #=> "mikel@lindsaar.net"
-    def spec
-      s = self.local
-      d = self.domain
-      if s and d
-        s + '@' + d
-      else
-        s
-      end
-    end
-
-    alias address spec
-
-    # Provides == function to the email.  Only checks the actual address
-    # and ignores the name/phrase component
-    # 
-    # For Example
-    # 
-    #  addr1 = TMail::Address.parse("My Address <mikel@lindsaar.net>")
-    #  #=> "#<TMail::Address mikel@lindsaar.net>"
-    #  addr2 = TMail::Address.parse("Another <mikel@lindsaar.net>")
-    #  #=> "#<TMail::Address mikel@lindsaar.net>"
-    #  addr1 == addr2
-    #  #=> true
-    def ==( other )
-      other.respond_to? :spec and self.spec == other.spec
-    end
-
-    alias eql? ==
-
-    # Provides a unique hash value for this record against the local and domain
-    # parts, ignores the name/phrase value
-    # 
-    #  email = TMail::Address.parse("mikel@lindsaar.net")
-    #  email.hash
-    #  #=> 18767598
-    def hash
-      @local.hash ^ @domain.hash
-    end
-
-    # Duplicates a TMail::Address object returning the duplicate
-    # 
-    #  addr1 = TMail::Address.parse("mikel@lindsaar.net")
-    #  addr2 = addr1.dup
-    #  addr1.id == addr2.id
-    #  #=> false
-    def dup
-      obj = self.class.new(@local.dup, @domain.dup)
-      obj.name = @name.dup if @name
-      obj.routes.replace @routes
-      obj
-    end
-
-    include StrategyInterface #:nodoc:
-
-    def accept( strategy, dummy1 = nil, dummy2 = nil ) #:nodoc:
-      unless @local
-        strategy.meta '<>'   # empty return-path
-        return
-      end
-
-      spec_p = (not @name and @routes.empty?)
-      if @name
-        strategy.phrase @name
-        strategy.space
-      end
-      tmp = spec_p ? '' : '<'
-      unless @routes.empty?
-        tmp << @routes.map {|i| '@' + i }.join(',') << ':'
-      end
-      tmp << self.spec
-      tmp << '>' unless spec_p
-      strategy.meta tmp
-      strategy.lwsp ''
-    end
-
-  end
-
-
-  class AddressGroup
-
-    include Enumerable
-
-    def address_group?
-      true
-    end
-
-    def initialize( name, addrs )
-      @name = name
-      @addresses = addrs
-    end
-
-    attr_reader :name
-    
-    def ==( other )
-      other.respond_to? :to_a and @addresses == other.to_a
-    end
-
-    alias eql? ==
-
-    def hash
-      map {|i| i.hash }.hash
-    end
-
-    def []( idx )
-      @addresses[idx]
-    end
-
-    def size
-      @addresses.size
-    end
-
-    def empty?
-      @addresses.empty?
-    end
-
-    def each( &block )
-      @addresses.each(&block)
-    end
-
-    def to_a
-      @addresses.dup
-    end
-
-    alias to_ary to_a
-
-    def include?( a )
-      @addresses.include? a
-    end
-
-    def flatten
-      set = []
-      @addresses.each do |a|
-        if a.respond_to? :flatten
-          set.concat a.flatten
-        else
-          set.push a
-        end
-      end
-      set
-    end
-
-    def each_address( &block )
-      flatten.each(&block)
-    end
-
-    def add( a )
-      @addresses.push a
-    end
-
-    alias push add
-    
-    def delete( a )
-      @addresses.delete a
-    end
-
-    include StrategyInterface
-
-    def accept( strategy, dummy1 = nil, dummy2 = nil )
-      strategy.phrase @name
-      strategy.meta ':'
-      strategy.space
-      first = true
-      each do |mbox|
-        if first
-          first = false
-        else
-          strategy.meta ','
-        end
-        strategy.space
-        mbox.accept strategy
-      end
-      strategy.meta ';'
-      strategy.lwsp ''
-    end
-
-  end
-
-end   # module TMail

actionmailer/lib/action_mailer/vendor/tmail-1.2.3/tmail/attachments.rb

@@ -1,46 +0,0 @@
-=begin rdoc
-
-= Attachment handling file
-
-=end
-
-require 'stringio'
-
-module TMail
-  class Attachment < StringIO
-    attr_accessor :original_filename, :content_type
-  end
-
-  class Mail
-    def has_attachments?
-      multipart? && parts.any? { |part| attachment?(part) }
-    end
-
-    def attachment?(part)
-      part.disposition_is_attachment? || part.content_type_is_text?
-    end
-
-    def attachments
-      if multipart?
-        parts.collect { |part| 
-          if part.multipart?
-            part.attachments
-          elsif attachment?(part)
-            content   = part.body # unquoted automatically by TMail#body
-            file_name = (part['content-location'] &&
-                          part['content-location'].body) ||
-                        part.sub_header("content-type", "name") ||
-                        part.sub_header("content-disposition", "filename")
-            
-            next if file_name.blank? || content.blank?
-            
-            attachment = Attachment.new(content)
-            attachment.original_filename = file_name.strip
-            attachment.content_type = part.content_type
-            attachment
-          end
-        }.flatten.compact
-      end      
-    end
-  end
-end

actionmailer/lib/action_mailer/vendor/tmail-1.2.3/tmail/base64.rb

@@ -1,46 +0,0 @@
-#--
-#   Copyright (c) 1998-2003 Minero Aoki <aamine@loveruby.net>
-#
-#   Permission is hereby granted, free of charge, to any person obtaining
-#   a copy of this software and associated documentation files (the
-#   "Software"), to deal in the Software without restriction, including
-#   without limitation the rights to use, copy, modify, merge, publish,
-#   distribute, sublicense, and/or sell copies of the Software, and to
-#   permit persons to whom the Software is furnished to do so, subject to
-#   the following conditions:
-#
-#   The above copyright notice and this permission notice shall be
-#   included in all copies or substantial portions of the Software.
-#
-#   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-#   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-#   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-#   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-#   LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-#   OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-#   WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-#   Note: Originally licensed under LGPL v2+. Using MIT license for Rails
-#   with permission of Minero Aoki.
-#++
-#:stopdoc:
-module TMail
-  module Base64
-
-    module_function
-
-    def folding_encode( str, eol = "\n", limit = 60 )
-      [str].pack('m')
-    end
-
-    def encode( str )
-      [str].pack('m').tr( "\r\n", '' )
-    end
-
-    def decode( str, strict = false )
-      str.unpack('m').first
-    end
-
-  end
-end
-#:startdoc:

actionmailer/lib/action_mailer/vendor/tmail-1.2.3/tmail/compat.rb

@@ -1,41 +0,0 @@
-#:stopdoc:
-unless Enumerable.method_defined?(:map) 
-  module Enumerable #:nodoc:
-    alias map collect
-  end
-end
-
-unless Enumerable.method_defined?(:select)
-  module Enumerable #:nodoc:
-    alias select find_all
-  end
-end
-
-unless Enumerable.method_defined?(:reject)
-  module Enumerable #:nodoc:
-    def reject
-      result = []
-      each do |i|
-        result.push i unless yield(i)
-      end
-      result
-    end
-  end
-end
-
-unless Enumerable.method_defined?(:sort_by)
-  module Enumerable #:nodoc:
-    def sort_by
-      map {|i| [yield(i), i] }.sort.map {|val, i| i }
-    end
-  end
-end
-
-unless File.respond_to?(:read)
-  def File.read(fname) #:nodoc:
-    File.open(fname) {|f|
-      return f.read
-    }
-  end
-end
-#:startdoc:

actionmailer/lib/action_mailer/vendor/tmail-1.2.3/tmail/config.rb

@@ -1,67 +0,0 @@
-#--
-# Copyright (c) 1998-2003 Minero Aoki <aamine@loveruby.net>
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-# Note: Originally licensed under LGPL v2+. Using MIT license for Rails
-# with permission of Minero Aoki.
-#++
-#:stopdoc:
-module TMail
-
-  class Config
-
-    def initialize( strict )
-      @strict_parse = strict
-      @strict_base64decode = strict
-    end
-
-    def strict_parse?
-      @strict_parse
-    end
-
-    attr_writer :strict_parse
-
-    def strict_base64decode?
-      @strict_base64decode
-    end
-
-    attr_writer :strict_base64decode
-
-    def new_body_port( mail )
-      StringPort.new
-    end
-
-    alias new_preamble_port  new_body_port
-    alias new_part_port      new_body_port
-  
-  end
-
-  DEFAULT_CONFIG        = Config.new(false)
-  DEFAULT_STRICT_CONFIG = Config.new(true)
-
-  def Config.to_config( arg )
-    return DEFAULT_STRICT_CONFIG if arg == true
-    return DEFAULT_CONFIG        if arg == false
-    arg or DEFAULT_CONFIG
-  end
-
-end
-#:startdoc:

actionmailer/lib/action_mailer/vendor/tmail-1.2.3/tmail/core_extensions.rb

@@ -1,63 +0,0 @@
-#:stopdoc:
-unless Object.respond_to?(:blank?)
-  class Object
-    # Check first to see if we are in a Rails environment, no need to 
-    # define these methods if we are
-
-    # An object is blank if it's nil, empty, or a whitespace string.
-    # For example, "", "   ", nil, [], and {} are blank.
-    #
-    # This simplifies
-    #   if !address.nil? && !address.empty?
-    # to
-    #   if !address.blank?
-    def blank?
-      if respond_to?(:empty?) && respond_to?(:strip)
-        empty? or strip.empty?
-      elsif respond_to?(:empty?)
-        empty?
-      else
-        !self
-      end
-    end
-  end
-
-  class NilClass
-    def blank?
-      true
-    end
-  end
-
-  class FalseClass
-    def blank?
-      true
-    end
-  end
-
-  class TrueClass
-    def blank?
-      false
-    end
-  end
-
-  class Array
-    alias_method :blank?, :empty?
-  end
-
-  class Hash
-    alias_method :blank?, :empty?
-  end
-
-  class String
-    def blank?
-      empty? || strip.empty?
-    end
-  end
-
-  class Numeric
-    def blank?
-      false
-    end
-  end
-end
-#:startdoc:

actionmailer/lib/action_mailer/vendor/tmail-1.2.3/tmail/encode.rb

@@ -1,581 +0,0 @@
-#--
-# = COPYRIGHT:
-#
-#   Copyright (c) 1998-2003 Minero Aoki <aamine@loveruby.net>
-#
-#   Permission is hereby granted, free of charge, to any person obtaining
-#   a copy of this software and associated documentation files (the
-#   "Software"), to deal in the Software without restriction, including
-#   without limitation the rights to use, copy, modify, merge, publish,
-#   distribute, sublicense, and/or sell copies of the Software, and to
-#   permit persons to whom the Software is furnished to do so, subject to
-#   the following conditions:
-#
-#   The above copyright notice and this permission notice shall be
-#   included in all copies or substantial portions of the Software.
-#
-#   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-#   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-#   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-#   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-#   LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-#   OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-#   WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-#   Note: Originally licensed under LGPL v2+. Using MIT license for Rails
-#   with permission of Minero Aoki.
-#++
-#:stopdoc:
-require 'nkf'
-require 'tmail/base64'
-require 'tmail/stringio'
-require 'tmail/utils'
-#:startdoc:
-
-
-module TMail
-  
-  #:stopdoc:
-  class << self
-    attr_accessor :KCODE
-  end
-  self.KCODE = 'NONE'
-
-  module StrategyInterface
-
-    def create_dest( obj )
-      case obj
-      when nil
-        StringOutput.new
-      when String
-        StringOutput.new(obj)
-      when IO, StringOutput
-        obj
-      else
-        raise TypeError, 'cannot handle this type of object for dest'
-      end
-    end
-    module_function :create_dest
-
-    #:startdoc:
-    # Returns the TMail object encoded and ready to be sent via SMTP etc.
-    # You should call this before you are packaging up your  email to
-    # correctly escape all the values that need escaping in the email, line
-    # wrap the email etc.
-    # 
-    # It is also a good idea to call this before you marshal or serialize
-    # a TMail object.
-    # 
-    # For Example:
-    # 
-    #  email = TMail::Load(my_email_file)
-    #  email_to_send = email.encoded
-    def encoded( eol = "\r\n", charset = 'j', dest = nil )
-      accept_strategy Encoder, eol, charset, dest
-    end
-
-    # Returns the TMail object decoded and ready to be used by you, your
-    # program etc.
-    # 
-    # You should call this before you are packaging up your  email to
-    # correctly escape all the values that need escaping in the email, line
-    # wrap the email etc.
-    # 
-    # For Example:
-    # 
-    #  email = TMail::Load(my_email_file)
-    #  email_to_send = email.encoded
-    def decoded( eol = "\n", charset = 'e', dest = nil )
-      # Turn the E-Mail into a string and return it with all
-      # encoded characters decoded.  alias for to_s
-      accept_strategy Decoder, eol, charset, dest
-    end
-
-    alias to_s decoded
-
-    def accept_strategy( klass, eol, charset, dest = nil ) #:nodoc:
-      dest ||= ''
-      accept klass.new( create_dest(dest), charset, eol )
-      dest
-    end
-
-  end
-
-  #:stopdoc:
-
-  ###
-  ### MIME B encoding decoder
-  ###
-
-  class Decoder
-
-    include TextUtils
-
-    encoded = '=\?(?:iso-2022-jp|euc-jp|shift_jis)\?[QB]\?[a-z0-9+/=]+\?='
-    ENCODED_WORDS = /#{encoded}(?:\s+#{encoded})*/i
-
-    OUTPUT_ENCODING = {
-      'EUC'  => 'e',
-      'SJIS' => 's',
-    }
-
-    def self.decode( str, encoding = nil )
-      encoding ||= (OUTPUT_ENCODING[TMail.KCODE] || 'j')
-      opt = '-mS' + encoding
-      str.gsub(ENCODED_WORDS) {|s| NKF.nkf(opt, s) }
-    end
-
-    def initialize( dest, encoding = nil, eol = "\n" )
-      @f = StrategyInterface.create_dest(dest)
-      @encoding = (/\A[ejs]/ === encoding) ? encoding[0,1] : nil
-      @eol = eol
-    end
-
-    def decode( str )
-      self.class.decode(str, @encoding)
-    end
-    private :decode
-
-    def terminate
-    end
-
-    def header_line( str )
-      @f << decode(str)
-    end
-
-    def header_name( nm )
-      @f << nm << ': '
-    end
-
-    def header_body( str )
-      @f << decode(str)
-    end
-
-    def space
-      @f << ' '
-    end
-
-    alias spc space
-
-    def lwsp( str )
-      @f << str
-    end
-
-    def meta( str )
-      @f << str
-    end
-
-    def text( str )
-      @f << decode(str)
-    end
-
-    def phrase( str )
-      @f << quote_phrase(decode(str))
-    end
-
-    def kv_pair( k, v )
-      v = dquote(v) unless token_safe?(v)
-      @f << k << '=' << v
-    end
-
-    def puts( str = nil )
-      @f << str if str
-      @f << @eol
-    end
-
-    def write( str )
-      @f << str
-    end
-
-  end
-
-
-  ###
-  ### MIME B-encoding encoder
-  ###
-
-  #
-  # FIXME: This class can handle only (euc-jp/shift_jis -> iso-2022-jp).
-  #
-  class Encoder
-
-    include TextUtils
-
-    BENCODE_DEBUG = false unless defined?(BENCODE_DEBUG)
-
-    def Encoder.encode( str )
-      e = new()
-      e.header_body str
-      e.terminate
-      e.dest.string
-    end
-
-    SPACER       = "\t"
-    MAX_LINE_LEN = 78
-    RFC_2822_MAX_LENGTH = 998
-
-    OPTIONS = {
-      'EUC'  => '-Ej -m0',
-      'SJIS' => '-Sj -m0',
-      'UTF8' => nil,      # FIXME
-      'NONE' => nil
-    }
-
-    def initialize( dest = nil, encoding = nil, eol = "\r\n", limit = nil )
-      @f = StrategyInterface.create_dest(dest)
-      @opt = OPTIONS[TMail.KCODE]
-      @eol = eol
-      @folded = false
-      @preserve_quotes = true
-      reset
-    end
-
-    def preserve_quotes=( bool )
-      @preserve_quotes
-    end
-
-    def preserve_quotes
-      @preserve_quotes
-    end
-
-    def normalize_encoding( str )
-      if @opt
-      then NKF.nkf(@opt, str)
-      else str
-      end
-    end
-
-    def reset
-      @text = ''
-      @lwsp = ''
-      @curlen = 0
-    end
-
-    def terminate
-      add_lwsp ''
-      reset
-    end
-
-    def dest
-      @f
-    end
-
-    def puts( str = nil )
-      @f << str if str
-      @f << @eol
-    end
-
-    def write( str )
-      @f << str
-    end
-
-    #
-    # add
-    #
-
-    def header_line( line )
-      scanadd line
-    end
-
-    def header_name( name )
-      add_text name.split(/-/).map {|i| i.capitalize }.join('-')
-      add_text ':'
-      add_lwsp ' '
-    end
-
-    def header_body( str )
-      scanadd normalize_encoding(str)
-    end
-
-    def space
-      add_lwsp ' '
-    end
-
-    alias spc space
-
-    def lwsp( str )
-      add_lwsp str.sub(/[\r\n]+[^\r\n]*\z/, '')
-    end
-
-    def meta( str )
-      add_text str
-    end
-
-    def text( str )
-      scanadd normalize_encoding(str)
-    end
-
-    def phrase( str )
-      str = normalize_encoding(str)
-      if CONTROL_CHAR === str
-        scanadd str
-      else
-        add_text quote_phrase(str)
-      end
-    end
-
-    # FIXME: implement line folding
-    #
-    def kv_pair( k, v )
-      return if v.nil?
-      v = normalize_encoding(v)
-      if token_safe?(v)
-        add_text k + '=' + v
-      elsif not CONTROL_CHAR === v
-        add_text k + '=' + quote_token(v)
-      else
-        # apply RFC2231 encoding
-        kv = k + '*=' + "iso-2022-jp'ja'" + encode_value(v)
-        add_text kv
-      end
-    end
-
-    def encode_value( str )
-      str.gsub(TOKEN_UNSAFE) {|s| '%%%02x' % s[0] }
-    end
-
-    private
-
-    def scanadd( str, force = false )
-      types = ''
-      strs = []
-      if str.respond_to?(:encoding)
-        enc = str.encoding 
-        str.force_encoding(Encoding::ASCII_8BIT)
-      end
-      until str.empty?
-        if m = /\A[^\e\t\r\n ]+/.match(str)
-          types << (force ? 'j' : 'a')
-          if str.respond_to?(:encoding)
-            strs.push m[0].force_encoding(enc)
-          else
-            strs.push m[0]
-          end
-        elsif m = /\A[\t\r\n ]+/.match(str)
-          types << 's'
-          if str.respond_to?(:encoding)
-            strs.push m[0].force_encoding(enc)
-          else
-            strs.push m[0]
-          end
-
-        elsif m = /\A\e../.match(str)
-          esc = m[0]
-          str = m.post_match
-          if esc != "\e(B" and m = /\A[^\e]+/.match(str)
-            types << 'j'
-            if str.respond_to?(:encoding)
-              strs.push m[0].force_encoding(enc)
-            else
-              strs.push m[0]
-            end
-          end
-
-        else
-          raise 'TMail FATAL: encoder scan fail'
-        end
-        (str = m.post_match) unless m.nil?
-      end
-
-      do_encode types, strs
-    end
-
-    def do_encode( types, strs )
-      #
-      # result  : (A|E)(S(A|E))*
-      # E       : W(SW)*
-      # W       : (J|A)+ but must contain J  # (J|A)*J(J|A)*
-      # A       : <<A character string not to be encoded>>
-      # J       : <<A character string to be encoded>>
-      # S       : <<LWSP>>
-      #
-      # An encoding unit is `E'.
-      # Input (parameter `types') is  (J|A)(J|A|S)*(J|A)
-      #
-      if BENCODE_DEBUG
-        puts
-        puts '-- do_encode ------------'
-        puts types.split(//).join(' ')
-        p strs
-      end
-
-      e = /[ja]*j[ja]*(?:s[ja]*j[ja]*)*/
-
-      while m = e.match(types)
-        pre = m.pre_match
-        concat_A_S pre, strs[0, pre.size] unless pre.empty?
-        concat_E m[0], strs[m.begin(0) ... m.end(0)]
-        types = m.post_match
-        strs.slice! 0, m.end(0)
-      end
-      concat_A_S types, strs
-    end
-
-    def concat_A_S( types, strs )
-      if RUBY_VERSION < '1.9'
-        a = ?a; s = ?s
-      else
-        a = 'a'.ord; s = 's'.ord
-      end
-      i = 0
-      types.each_byte do |t|
-        case t
-        when a then add_text strs[i]
-        when s then add_lwsp strs[i]
-        else
-          raise "TMail FATAL: unknown flag: #{t.chr}"
-        end
-        i += 1
-      end
-    end
-
-    METHOD_ID = {
-      ?j => :extract_J,
-      ?e => :extract_E,
-      ?a => :extract_A,
-      ?s => :extract_S
-    }
-
-    def concat_E( types, strs )
-      if BENCODE_DEBUG
-        puts '---- concat_E'
-        puts "types=#{types.split(//).join(' ')}"
-        puts "strs =#{strs.inspect}"
-      end
-
-      flush() unless @text.empty?
-
-      chunk = ''
-      strs.each_with_index do |s,i|
-        mid = METHOD_ID[types[i]]
-        until s.empty?
-          unless c = __send__(mid, chunk.size, s)
-            add_with_encode chunk unless chunk.empty?
-            flush
-            chunk = ''
-            fold
-            c = __send__(mid, 0, s)
-            raise 'TMail FATAL: extract fail' unless c
-          end
-          chunk << c
-        end
-      end
-      add_with_encode chunk unless chunk.empty?
-    end
-
-    def extract_J( chunksize, str )
-      size = max_bytes(chunksize, str.size) - 6
-      size = (size % 2 == 0) ? (size) : (size - 1)
-      return nil if size <= 0
-      if str.respond_to?(:encoding)
-        enc = str.encoding
-        str.force_encoding(Encoding::ASCII_8BIT)
-        "\e$B#{str.slice!(0, size)}\e(B".force_encoding(enc)
-      else
-        "\e$B#{str.slice!(0, size)}\e(B"
-      end
-    end
-
-    def extract_A( chunksize, str )
-      size = max_bytes(chunksize, str.size)
-      return nil if size <= 0
-      str.slice!(0, size)
-    end
-
-    alias extract_S extract_A
-
-    def max_bytes( chunksize, ssize )
-      (restsize() - '=?iso-2022-jp?B??='.size) / 4 * 3 - chunksize
-    end
-
-    #
-    # free length buffer
-    #
-
-    def add_text( str )
-      @text << str
-      # puts '---- text -------------------------------------'
-      # puts "+ #{str.inspect}"
-      # puts "txt >>>#{@text.inspect}<<<"
-    end
-
-    def add_with_encode( str )
-      @text << "=?iso-2022-jp?B?#{Base64.encode(str)}?="
-    end
-
-    def add_lwsp( lwsp )
-      # puts '---- lwsp -------------------------------------'
-      # puts "+ #{lwsp.inspect}"
-      fold if restsize() <= 0
-      flush(@folded)
-      @lwsp = lwsp
-    end
-
-    def flush(folded = false)
-      # puts '---- flush ----'
-      # puts "spc >>>#{@lwsp.inspect}<<<"
-      # puts "txt >>>#{@text.inspect}<<<"
-      @f << @lwsp << @text
-      if folded
-        @curlen = 0
-      else
-        @curlen += (@lwsp.size + @text.size)
-      end
-      @text = ''
-      @lwsp = ''
-    end
-
-    def fold
-      # puts '---- fold ----'
-      unless @f.string =~ /^.*?:$/
-        @f << @eol
-        @lwsp = SPACER
-      else
-        fold_header
-        @folded = true
-      end
-      @curlen = 0
-    end
-
-    def fold_header
-      # Called because line is too long - so we need to wrap.
-      # First look for whitespace in the text
-      # if it has text, fold there
-      # check the remaining text, if too long, fold again
-      # if it doesn't, then don't fold unless the line goes beyond 998 chars
-
-      # Check the text to see if there is whitespace, or if not
-      @wrapped_text = []
-      until @text.blank?
-        fold_the_string
-      end
-      @text = @wrapped_text.join("#{@eol}#{SPACER}")
-    end
-
-    def fold_the_string
-      whitespace_location = @text =~ /\s/ || @text.length
-      # Is the location of the whitespace shorter than the RCF_2822_MAX_LENGTH?
-      # if there is no whitespace in the string, then this
-      unless mazsize(whitespace_location) <= 0
-        @text.strip!
-        @wrapped_text << @text.slice!(0...whitespace_location)
-      # If it is not less, we have to wrap it destructively
-      else
-        slice_point = RFC_2822_MAX_LENGTH - @curlen - @lwsp.length
-        @text.strip!
-        @wrapped_text << @text.slice!(0...slice_point)
-      end
-    end
-
-    def restsize
-      MAX_LINE_LEN - (@curlen + @lwsp.size + @text.size)
-    end
-
-    def mazsize(whitespace_location)
-      # Per RFC2822, the maximum length of a line is 998 chars
-      RFC_2822_MAX_LENGTH - (@curlen + @lwsp.size + whitespace_location)
-    end
-
-  end
-  #:startdoc:
-end    # module TMail

actionmailer/lib/action_mailer/vendor/tmail-1.2.3/tmail/header.rb

@@ -1,960 +0,0 @@
-#--
-# Copyright (c) 1998-2003 Minero Aoki <aamine@loveruby.net>
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-# Note: Originally licensed under LGPL v2+. Using MIT license for Rails
-# with permission of Minero Aoki.
-#++
-
-require 'tmail/encode'
-require 'tmail/address'
-require 'tmail/parser'
-require 'tmail/config'
-require 'tmail/utils'
-
-#:startdoc:
-module TMail
-
-  # Provides methods to handle and manipulate headers in the email
-  class HeaderField
-
-    include TextUtils
-
-    class << self
-
-      alias newobj new
-
-      def new( name, body, conf = DEFAULT_CONFIG )
-        klass = FNAME_TO_CLASS[name.downcase] || UnstructuredHeader
-        klass.newobj body, conf
-      end
-
-      # Returns a HeaderField object matching the header you specify in the "name" param.
-      # Requires an initialized TMail::Port to be passed in.
-      #
-      # The method searches the header of the Port you pass into it to find a match on
-      # the header line you pass.  Once a match is found, it will unwrap the matching line
-      # as needed to return an initialized HeaderField object.
-      #
-      # If you want to get the Envelope sender of the email object, pass in "EnvelopeSender",
-      # if you want the From address of the email itself, pass in 'From'.
-      #
-      # This is because a mailbox doesn't have the : after the From that designates the
-      # beginning of the envelope sender (which can be different to the from address of 
-      # the email)
-      #
-      # Other fields can be passed as normal, "Reply-To", "Received" etc.
-      #
-      # Note: Change of behaviour in 1.2.1 => returns nil if it does not find the specified
-      # header field, otherwise returns an instantiated object of the correct header class
-      # 
-      # For example:
-      #   port = TMail::FilePort.new("/test/fixtures/raw_email_simple")
-      #   h = TMail::HeaderField.new_from_port(port, "From")
-      #   h.addrs.to_s #=> "Mikel Lindsaar <mikel@nowhere.com>"
-      #   h = TMail::HeaderField.new_from_port(port, "EvelopeSender")
-      #   h.addrs.to_s #=> "mike@anotherplace.com.au"
-      #   h = TMail::HeaderField.new_from_port(port, "SomeWeirdHeaderField")
-      #   h #=> nil
-      def new_from_port( port, name, conf = DEFAULT_CONFIG )
-        if name == "EnvelopeSender"
-          name = "From"
-          re = Regexp.new('\A(From) ', 'i')
-        else
-          re = Regexp.new('\A(' + Regexp.quote(name) + '):', 'i')
-        end
-        str = nil
-        port.ropen {|f|
-            f.each do |line|
-              if m = re.match(line)            then str = m.post_match.strip
-              elsif str and /\A[\t ]/ === line then str << ' ' << line.strip
-              elsif /\A-*\s*\z/ === line       then break
-              elsif str                        then break
-              end
-            end
-        }
-        new(name, str, Config.to_config(conf)) if str
-      end
-
-      def internal_new( name, conf )
-        FNAME_TO_CLASS[name].newobj('', conf, true)
-      end
-
-    end   # class << self
-
-    def initialize( body, conf, intern = false )
-      @body = body
-      @config = conf
-
-      @illegal = false
-      @parsed = false
-      
-      if intern
-        @parsed = true
-        parse_init
-      end
-    end
-
-    def inspect
-      "#<#{self.class} #{@body.inspect}>"
-    end
-
-    def illegal?
-      @illegal
-    end
-
-    def empty?
-      ensure_parsed
-      return true if @illegal
-      isempty?
-    end
-
-    private
-
-    def ensure_parsed
-      return if @parsed
-      @parsed = true
-      parse
-    end
-
-    # defabstract parse
-    # end
-
-    def clear_parse_status
-      @parsed = false
-      @illegal = false
-    end
-
-    public
-
-    def body
-      ensure_parsed
-      v = Decoder.new(s = '')
-      do_accept v
-      v.terminate
-      s
-    end
-
-    def body=( str )
-      @body = str
-      clear_parse_status
-    end
-
-    include StrategyInterface
-
-    def accept( strategy )
-      ensure_parsed
-      do_accept strategy
-      strategy.terminate
-    end
-
-    # abstract do_accept
-
-  end
-
-
-  class UnstructuredHeader < HeaderField
-
-    def body
-      ensure_parsed
-      @body
-    end
-
-    def body=( arg )
-      ensure_parsed
-      @body = arg
-    end
-
-    private
-
-    def parse_init
-    end
-
-    def parse
-      @body = Decoder.decode(@body.gsub(/\n|\r\n|\r/, ''))
-    end
-
-    def isempty?
-      not @body
-    end
-
-    def do_accept( strategy )
-      strategy.text @body
-    end
-
-  end
-
-
-  class StructuredHeader < HeaderField
-
-    def comments
-      ensure_parsed
-      if @comments[0]
-        [Decoder.decode(@comments[0])]
-      else
-        @comments
-      end
-    end
-
-    private
-
-    def parse
-      save = nil
-
-      begin
-        parse_init
-        do_parse
-      rescue SyntaxError
-        if not save and mime_encoded? @body
-          save = @body
-          @body = Decoder.decode(save)
-          retry
-        elsif save
-          @body = save
-        end
-
-        @illegal = true
-        raise if @config.strict_parse?
-      end
-    end
-
-    def parse_init
-      @comments = []
-      init
-    end
-
-    def do_parse
-      quote_boundary
-      obj = Parser.parse(self.class::PARSE_TYPE, @body, @comments)
-      set obj if obj
-    end
-
-  end
-
-
-  class DateTimeHeader < StructuredHeader
-
-    PARSE_TYPE = :DATETIME
-
-    def date
-      ensure_parsed
-      @date
-    end
-
-    def date=( arg )
-      ensure_parsed
-      @date = arg
-    end
-
-    private
-
-    def init
-      @date = nil
-    end
-
-    def set( t )
-      @date = t
-    end
-
-    def isempty?
-      not @date
-    end
-
-    def do_accept( strategy )
-      strategy.meta time2str(@date)
-    end
-
-  end
-
-
-  class AddressHeader < StructuredHeader
-
-    PARSE_TYPE = :MADDRESS
-
-    def addrs
-      ensure_parsed
-      @addrs
-    end
-
-    private
-
-    def init
-      @addrs = []
-    end
-
-    def set( a )
-      @addrs = a
-    end
-
-    def isempty?
-      @addrs.empty?
-    end
-
-    def do_accept( strategy )
-      first = true
-      @addrs.each do |a|
-        if first
-          first = false
-        else
-          strategy.meta ','
-          strategy.space
-        end
-        a.accept strategy
-      end
-
-      @comments.each do |c|
-        strategy.space
-        strategy.meta '('
-        strategy.text c
-        strategy.meta ')'
-      end
-    end
-
-  end
-
-
-  class ReturnPathHeader < AddressHeader
-
-    PARSE_TYPE = :RETPATH
-
-    def addr
-      addrs()[0]
-    end
-
-    def spec
-      a = addr() or return nil
-      a.spec
-    end
-
-    def routes
-      a = addr() or return nil
-      a.routes
-    end
-
-    private
-
-    def do_accept( strategy )
-      a = addr()
-
-      strategy.meta '<'
-      unless a.routes.empty?
-        strategy.meta a.routes.map {|i| '@' + i }.join(',')
-        strategy.meta ':'
-      end
-      spec = a.spec
-      strategy.meta spec if spec
-      strategy.meta '>'
-    end
-
-  end
-
-
-  class SingleAddressHeader < AddressHeader
-
-    def addr
-      addrs()[0]
-    end
-
-    private
-
-    def do_accept( strategy )
-      a = addr()
-      a.accept strategy
-      @comments.each do |c|
-        strategy.space
-        strategy.meta '('
-        strategy.text c
-        strategy.meta ')'
-      end
-    end
-
-  end
-
-
-  class MessageIdHeader < StructuredHeader
-
-    def id
-      ensure_parsed
-      @id
-    end
-
-    def id=( arg )
-      ensure_parsed
-      @id = arg
-    end
-
-    private
-
-    def init
-      @id = nil
-    end
-
-    def isempty?
-      not @id
-    end
-
-    def do_parse
-      @id = @body.slice(MESSAGE_ID) or
-              raise SyntaxError, "wrong Message-ID format: #{@body}"
-    end
-
-    def do_accept( strategy )
-      strategy.meta @id
-    end
-
-  end
-
-
-  class ReferencesHeader < StructuredHeader
-
-    def refs
-      ensure_parsed
-      @refs
-    end
-
-    def each_id
-      self.refs.each do |i|
-        yield i if MESSAGE_ID === i
-      end
-    end
-
-    def ids
-      ensure_parsed
-      @ids
-    end
-
-    def each_phrase
-      self.refs.each do |i|
-        yield i unless MESSAGE_ID === i
-      end
-    end
-
-    def phrases
-      ret = []
-      each_phrase {|i| ret.push i }
-      ret
-    end
-
-    private
-
-    def init
-      @refs = []
-      @ids = []
-    end
-
-    def isempty?
-      @ids.empty?
-    end
-
-    def do_parse
-      str = @body
-      while m = MESSAGE_ID.match(str)
-        pre = m.pre_match.strip
-        @refs.push pre unless pre.empty?
-        @refs.push s = m[0]
-        @ids.push s
-        str = m.post_match
-      end
-      str = str.strip
-      @refs.push str unless str.empty?
-    end
-
-    def do_accept( strategy )
-      first = true
-      @ids.each do |i|
-        if first
-          first = false
-        else
-          strategy.space
-        end
-        strategy.meta i
-      end
-    end
-
-  end
-
-
-  class ReceivedHeader < StructuredHeader
-
-    PARSE_TYPE = :RECEIVED
-
-    def from
-      ensure_parsed
-      @from
-    end
-
-    def from=( arg )
-      ensure_parsed
-      @from = arg
-    end
-
-    def by
-      ensure_parsed
-      @by
-    end
-
-    def by=( arg )
-      ensure_parsed
-      @by = arg
-    end
-
-    def via
-      ensure_parsed
-      @via
-    end
-
-    def via=( arg )
-      ensure_parsed
-      @via = arg
-    end
-
-    def with
-      ensure_parsed
-      @with
-    end
-
-    def id
-      ensure_parsed
-      @id
-    end
-
-    def id=( arg )
-      ensure_parsed
-      @id = arg
-    end
-
-    def _for
-      ensure_parsed
-      @_for
-    end
-
-    def _for=( arg )
-      ensure_parsed
-      @_for = arg
-    end
-
-    def date
-      ensure_parsed
-      @date
-    end
-
-    def date=( arg )
-      ensure_parsed
-      @date = arg
-    end
-
-    private
-
-    def init
-      @from = @by = @via = @with = @id = @_for = nil
-      @with = []
-      @date = nil
-    end
-
-    def set( args )
-      @from, @by, @via, @with, @id, @_for, @date = *args
-    end
-
-    def isempty?
-      @with.empty? and not (@from or @by or @via or @id or @_for or @date)
-    end
-
-    def do_accept( strategy )
-      list = []
-      list.push 'from '  + @from       if @from
-      list.push 'by '    + @by         if @by
-      list.push 'via '   + @via        if @via
-      @with.each do |i|
-        list.push 'with ' + i
-      end
-      list.push 'id '    + @id         if @id
-      list.push 'for <'  + @_for + '>' if @_for
-
-      first = true
-      list.each do |i|
-        strategy.space unless first
-        strategy.meta i
-        first = false
-      end
-      if @date
-        strategy.meta ';'
-        strategy.space
-        strategy.meta time2str(@date)
-      end
-    end
-
-  end
-
-
-  class KeywordsHeader < StructuredHeader
-
-    PARSE_TYPE = :KEYWORDS
-
-    def keys
-      ensure_parsed
-      @keys
-    end
-
-    private
-
-    def init
-      @keys = []
-    end
-
-    def set( a )
-      @keys = a
-    end
-
-    def isempty?
-      @keys.empty?
-    end
-
-    def do_accept( strategy )
-      first = true
-      @keys.each do |i|
-        if first
-          first = false
-        else
-          strategy.meta ','
-        end
-        strategy.meta i
-      end
-    end
-
-  end
-
-
-  class EncryptedHeader < StructuredHeader
-
-    PARSE_TYPE = :ENCRYPTED
-
-    def encrypter
-      ensure_parsed
-      @encrypter
-    end
-
-    def encrypter=( arg )
-      ensure_parsed
-      @encrypter = arg
-    end
-
-    def keyword
-      ensure_parsed
-      @keyword
-    end
-
-    def keyword=( arg )
-      ensure_parsed
-      @keyword = arg
-    end
-
-    private
-
-    def init
-      @encrypter = nil
-      @keyword = nil
-    end
-
-    def set( args )
-      @encrypter, @keyword = args
-    end
-
-    def isempty?
-      not (@encrypter or @keyword)
-    end
-
-    def do_accept( strategy )
-      if @key
-        strategy.meta @encrypter + ','
-        strategy.space
-        strategy.meta @keyword
-      else
-        strategy.meta @encrypter
-      end
-    end
-
-  end
-
-
-  class MimeVersionHeader < StructuredHeader
-
-    PARSE_TYPE = :MIMEVERSION
-
-    def major
-      ensure_parsed
-      @major
-    end
-
-    def major=( arg )
-      ensure_parsed
-      @major = arg
-    end
-
-    def minor
-      ensure_parsed
-      @minor
-    end
-
-    def minor=( arg )
-      ensure_parsed
-      @minor = arg
-    end
-
-    def version
-      sprintf('%d.%d', major, minor)
-    end
-
-    private
-
-    def init
-      @major = nil
-      @minor = nil
-    end
-
-    def set( args )
-      @major, @minor = *args
-    end
-
-    def isempty?
-      not (@major or @minor)
-    end
-
-    def do_accept( strategy )
-      strategy.meta sprintf('%d.%d', @major, @minor)
-    end
-
-  end
-
-
-  class ContentTypeHeader < StructuredHeader
-
-    PARSE_TYPE = :CTYPE
-
-    def main_type
-      ensure_parsed
-      @main
-    end
-
-    def main_type=( arg )
-      ensure_parsed
-      @main = arg.downcase
-    end
-
-    def sub_type
-      ensure_parsed
-      @sub
-    end
-
-    def sub_type=( arg )
-      ensure_parsed
-      @sub = arg.downcase
-    end
-
-    def content_type
-      ensure_parsed
-      @sub ? sprintf('%s/%s', @main, @sub) : @main
-    end
-
-    def params
-      ensure_parsed
-      unless @params.blank?
-        @params.each do |k, v|
-          @params[k] = unquote(v)
-        end
-      end
-      @params
-    end
-
-    def []( key )
-      ensure_parsed
-      @params and unquote(@params[key])
-    end
-
-    def []=( key, val )
-      ensure_parsed
-      (@params ||= {})[key] = val
-    end
-
-    private
-
-    def init
-      @main = @sub = @params = nil
-    end
-
-    def set( args )
-      @main, @sub, @params = *args
-    end
-
-    def isempty?
-      not (@main or @sub)
-    end
-
-    def do_accept( strategy )
-      if @sub
-        strategy.meta sprintf('%s/%s', @main, @sub)
-      else
-        strategy.meta @main
-      end
-      @params.each do |k,v|
-        if v
-          strategy.meta ';'
-          strategy.space
-          strategy.kv_pair k, v
-        end
-      end
-    end
-
-  end
-
-
-  class ContentTransferEncodingHeader < StructuredHeader
-
-    PARSE_TYPE = :CENCODING
-
-    def encoding
-      ensure_parsed
-      @encoding
-    end
-
-    def encoding=( arg )
-      ensure_parsed
-      @encoding = arg
-    end
-
-    private
-
-    def init
-      @encoding = nil
-    end
-
-    def set( s )
-      @encoding = s
-    end
-
-    def isempty?
-      not @encoding
-    end
-
-    def do_accept( strategy )
-      strategy.meta @encoding.capitalize
-    end
-
-  end
-
-
-  class ContentDispositionHeader < StructuredHeader
-
-    PARSE_TYPE = :CDISPOSITION
-
-    def disposition
-      ensure_parsed
-      @disposition
-    end
-
-    def disposition=( str )
-      ensure_parsed
-      @disposition = str.downcase
-    end
-
-    def params
-      ensure_parsed
-      unless @params.blank?
-        @params.each do |k, v|
-          @params[k] = unquote(v)
-        end
-      end
-      @params
-    end
-
-    def []( key )
-      ensure_parsed
-      @params and unquote(@params[key])
-    end
-
-    def []=( key, val )
-      ensure_parsed
-      (@params ||= {})[key] = val
-    end
-
-    private
-
-    def init
-      @disposition = @params = nil
-    end
-
-    def set( args )
-      @disposition, @params = *args
-    end
-
-    def isempty?
-      not @disposition and (not @params or @params.empty?)
-    end
-
-    def do_accept( strategy )
-      strategy.meta @disposition
-      @params.each do |k,v|
-        strategy.meta ';'
-        strategy.space
-        strategy.kv_pair k, unquote(v)
-      end
-    end
-      
-  end
-
-
-  class HeaderField   # redefine
-
-    FNAME_TO_CLASS = {
-      'date'                      => DateTimeHeader,
-      'resent-date'               => DateTimeHeader,
-      'to'                        => AddressHeader,
-      'cc'                        => AddressHeader,
-      'bcc'                       => AddressHeader,
-      'from'                      => AddressHeader,
-      'reply-to'                  => AddressHeader,
-      'resent-to'                 => AddressHeader,
-      'resent-cc'                 => AddressHeader,
-      'resent-bcc'                => AddressHeader,
-      'resent-from'               => AddressHeader,
-      'resent-reply-to'           => AddressHeader,
-      'sender'                    => SingleAddressHeader,
-      'resent-sender'             => SingleAddressHeader,
-      'return-path'               => ReturnPathHeader,
-      'message-id'                => MessageIdHeader,
-      'resent-message-id'         => MessageIdHeader,
-      'in-reply-to'               => ReferencesHeader,
-      'received'                  => ReceivedHeader,
-      'references'                => ReferencesHeader,
-      'keywords'                  => KeywordsHeader,
-      'encrypted'                 => EncryptedHeader,
-      'mime-version'              => MimeVersionHeader,
-      'content-type'              => ContentTypeHeader,
-      'content-transfer-encoding' => ContentTransferEncodingHeader,
-      'content-disposition'       => ContentDispositionHeader,
-      'content-id'                => MessageIdHeader,
-      'subject'                   => UnstructuredHeader,
-      'comments'                  => UnstructuredHeader,
-      'content-description'       => UnstructuredHeader
-    }
-
-  end
-
-end   # module TMail

actionmailer/lib/action_mailer/vendor/tmail-1.2.3/tmail/index.rb

@@ -1,9 +0,0 @@
-#:stopdoc:
-# This is here for Rolls. 
-# Rolls uses this instead of lib/tmail.rb.
-
-require 'tmail/version'
-require 'tmail/mail'
-require 'tmail/mailbox'
-require 'tmail/core_extensions'
-#:startdoc:

actionmailer/lib/action_mailer/vendor/tmail-1.2.3/tmail/loader.rb

@@ -1,3 +0,0 @@
-#:stopdoc:
-require 'tmail/mailbox'
-#:startdoc:

actionmailer/lib/action_mailer/vendor/tmail-1.2.3/tmail/mail.rb

@@ -1,578 +0,0 @@
-=begin rdoc
-
-= Mail class
-
-=end
-#--
-# Copyright (c) 1998-2003 Minero Aoki <aamine@loveruby.net>
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-# Note: Originally licensed under LGPL v2+. Using MIT license for Rails
-# with permission of Minero Aoki.
-#++
-
- 
-
-require 'tmail/interface'
-require 'tmail/encode'
-require 'tmail/header'
-require 'tmail/port'
-require 'tmail/config'
-require 'tmail/utils'
-require 'tmail/attachments'
-require 'tmail/quoting'
-require 'socket'
-
-module TMail
-
-  # == Mail Class
-  # 
-  # Accessing a TMail object done via the TMail::Mail class.  As email can be fairly complex
-  # creatures, you will find a large amount of accessor and setter methods in this class!
-  # 
-  # Most of the below methods handle the header, in fact, what TMail does best is handle the
-  # header of the email object.  There are only a few methods that deal directly with the body
-  # of the email, such as base64_encode and base64_decode.
-  # 
-  # === Using TMail inside your code
-  # 
-  # The usual way is to install the gem (see the {README}[link:/README] on how to do this) and
-  # then put at the top of your class:
-  # 
-  #  require 'tmail'
-  # 
-  # You can then create a new TMail object in your code with:
-  # 
-  #  @email = TMail::Mail.new
-  # 
-  # Or if you have an email as a string, you can initialize a new TMail::Mail object and get it
-  # to parse that string for you like so:
-  # 
-  #  @email = TMail::Mail.parse(email_text)
-  # 
-  # You can also read a single email off the disk, for example:
-  # 
-  #  @email = TMail::Mail.load('filename.txt')
-  # 
-  # Also, you can read a mailbox (usual unix mbox format) and end up with an array of TMail
-  # objects by doing something like this:
-  # 
-  #  # Note, we pass true as the last variable to open the mailbox read only
-  #  mailbox = TMail::UNIXMbox.new("mailbox", nil, true)
-  #  @emails = []
-  #  mailbox.each_port { |m| @emails << TMail::Mail.new(m) }
-  #
-  class Mail
-
-    class << self
-      
-      # Opens an email that has been saved out as a file by itself.
-      # 
-      # This function will read a file non-destructively and then parse
-      # the contents and return a TMail::Mail object.
-      # 
-      # Does not handle multiple email mailboxes (like a unix mbox) for that
-      # use the TMail::UNIXMbox class.
-      # 
-      # Example:
-      #  mail = TMail::Mail.load('filename')
-      # 
-      def load( fname )
-        new(FilePort.new(fname))
-      end
-
-      alias load_from load
-      alias loadfrom load
-      
-      # Parses an email from the supplied string and returns a TMail::Mail
-      # object.
-      # 
-      # Example:
-      #  require 'rubygems'; require 'tmail'
-      #  email_string =<<HEREDOC
-      #  To: mikel@lindsaar.net
-      #  From: mikel@me.com
-      #  Subject: This is a short Email
-      #  
-      #  Hello there Mikel!
-      #  
-      #  HEREDOC
-      #  mail = TMail::Mail.parse(email_string)
-      #  #=> #<TMail::Mail port=#<TMail::StringPort:id=0xa30ac0> bodyport=nil>
-      #  mail.body
-      #  #=> "Hello there Mikel!\n\n"
-      def parse( str )
-        new(StringPort.new(str))
-      end
-
-    end
-
-    def initialize( port = nil, conf = DEFAULT_CONFIG ) #:nodoc:
-      @port = port || StringPort.new
-      @config = Config.to_config(conf)
-
-      @header      = {}
-      @body_port   = nil
-      @body_parsed = false
-      @epilogue    = ''
-      @parts       = []
-
-      @port.ropen {|f|
-          parse_header f
-          parse_body f unless @port.reproducible?
-      }
-    end
-
-    # Provides access to the port this email is using to hold it's data
-    # 
-    # Example:
-    #  mail = TMail::Mail.parse(email_string)
-    #  mail.port
-    #  #=> #<TMail::StringPort:id=0xa2c952>
-    attr_reader :port
-
-    def inspect
-      "\#<#{self.class} port=#{@port.inspect} bodyport=#{@body_port.inspect}>"
-    end
-
-    #
-    # to_s interfaces
-    #
-
-    public
-
-    include StrategyInterface
-
-    def write_back( eol = "\n", charset = 'e' )
-      parse_body
-      @port.wopen {|stream| encoded eol, charset, stream }
-    end
-
-    def accept( strategy )
-      with_multipart_encoding(strategy) {
-          ordered_each do |name, field|
-            next if field.empty?
-            strategy.header_name canonical(name)
-            field.accept strategy
-            strategy.puts
-          end
-          strategy.puts
-          body_port().ropen {|r|
-              strategy.write r.read
-          }
-      }
-    end
-
-    private
-
-    def canonical( name )
-      name.split(/-/).map {|s| s.capitalize }.join('-')
-    end
-
-    def with_multipart_encoding( strategy )
-      if parts().empty?    # DO NOT USE @parts
-        yield
-
-      else
-        bound = ::TMail.new_boundary
-        if @header.key? 'content-type'
-          @header['content-type'].params['boundary'] = bound
-        else
-          store 'Content-Type', %<multipart/mixed; boundary="#{bound}">
-        end
-
-        yield
-
-        parts().each do |tm|
-          strategy.puts
-          strategy.puts '--' + bound
-          tm.accept strategy
-        end
-        strategy.puts
-        strategy.puts '--' + bound + '--'
-        strategy.write epilogue()
-      end
-    end
-
-    ###
-    ### header
-    ###
-
-    public
-
-    ALLOW_MULTIPLE = {
-      'received'          => true,
-      'resent-date'       => true,
-      'resent-from'       => true,
-      'resent-sender'     => true,
-      'resent-to'         => true,
-      'resent-cc'         => true,
-      'resent-bcc'        => true,
-      'resent-message-id' => true,
-      'comments'          => true,
-      'keywords'          => true
-    }
-    USE_ARRAY = ALLOW_MULTIPLE
-
-    def header
-      @header.dup
-    end
-
-    # Returns a TMail::AddressHeader object of the field you are querying.
-    # Examples:
-    #  @mail['from']  #=> #<TMail::AddressHeader "mikel@test.com.au">
-    #  @mail['to']    #=> #<TMail::AddressHeader "mikel@test.com.au">
-    #
-    # You can get the string value of this by passing "to_s" to the query:
-    # Example:
-    #  @mail['to'].to_s #=> "mikel@test.com.au"
-    def []( key )
-      @header[key.downcase]
-    end
-
-    def sub_header(key, param)
-      (hdr = self[key]) ? hdr[param] : nil
-    end
-
-    alias fetch []
-
-    # Allows you to set or delete TMail header objects at will.
-    # Examples:
-    #  @mail = TMail::Mail.new
-    #  @mail['to'].to_s       # => 'mikel@test.com.au'
-    #  @mail['to'] = 'mikel@elsewhere.org'
-    #  @mail['to'].to_s       # => 'mikel@elsewhere.org'
-    #  @mail.encoded          # => "To: mikel@elsewhere.org\r\n\r\n"
-    #  @mail['to'] = nil
-    #  @mail['to'].to_s       # => nil
-    #  @mail.encoded          # => "\r\n"
-    # 
-    # Note: setting mail[] = nil actually deletes the header field in question from the object,
-    # it does not just set the value of the hash to nil
-    def []=( key, val )
-      dkey = key.downcase
-
-      if val.nil?
-        @header.delete dkey
-        return nil
-      end
-
-      case val
-      when String
-        header = new_hf(key, val)
-      when HeaderField
-        ;
-      when Array
-        ALLOW_MULTIPLE.include? dkey or
-                raise ArgumentError, "#{key}: Header must not be multiple"
-        @header[dkey] = val
-        return val
-      else
-        header = new_hf(key, val.to_s)
-      end
-      if ALLOW_MULTIPLE.include? dkey
-        (@header[dkey] ||= []).push header
-      else
-        @header[dkey] = header
-      end
-
-      val
-    end
-
-    alias store []=
-    
-    # Allows you to loop through each header in the TMail::Mail object in a block
-    # Example:
-    #   @mail['to'] = 'mikel@elsewhere.org'
-    #   @mail['from'] = 'me@me.com'
-    #   @mail.each_header { |k,v| puts "#{k} = #{v}" }
-    #   # => from = me@me.com
-    #   # => to = mikel@elsewhere.org
-    def each_header
-      @header.each do |key, val|
-        [val].flatten.each {|v| yield key, v }
-      end
-    end
-
-    alias each_pair each_header
-
-    def each_header_name( &block )
-      @header.each_key(&block)
-    end
-
-    alias each_key each_header_name
-
-    def each_field( &block )
-      @header.values.flatten.each(&block)
-    end
-
-    alias each_value each_field
-
-    FIELD_ORDER = %w(
-      return-path received
-      resent-date resent-from resent-sender resent-to
-      resent-cc resent-bcc resent-message-id
-      date from sender reply-to to cc bcc
-      message-id in-reply-to references
-      subject comments keywords
-      mime-version content-type content-transfer-encoding
-      content-disposition content-description
-    )
-
-    def ordered_each
-      list = @header.keys
-      FIELD_ORDER.each do |name|
-        if list.delete(name)
-          [@header[name]].flatten.each {|v| yield name, v }
-        end
-      end
-      list.each do |name|
-        [@header[name]].flatten.each {|v| yield name, v }
-      end
-    end
-
-    def clear
-      @header.clear
-    end
-
-    def delete( key )
-      @header.delete key.downcase
-    end
-
-    def delete_if
-      @header.delete_if do |key,val|
-        if Array === val
-          val.delete_if {|v| yield key, v }
-          val.empty?
-        else
-          yield key, val
-        end
-      end
-    end
-
-    def keys
-      @header.keys
-    end
-
-    def key?( key )
-      @header.key? key.downcase
-    end
-
-    def values_at( *args )
-      args.map {|k| @header[k.downcase] }.flatten
-    end
-
-    alias indexes values_at
-    alias indices values_at
-
-    private
-
-    def parse_header( f )
-      name = field = nil
-      unixfrom = nil
-
-      while line = f.gets
-        case line
-        when /\A[ \t]/             # continue from prev line
-          raise SyntaxError, 'mail is began by space' unless field
-          field << ' ' << line.strip
-
-        when /\A([^\: \t]+):\s*/   # new header line
-          add_hf name, field if field
-          name = $1
-          field = $' #.strip
-
-        when /\A\-*\s*\z/          # end of header
-          add_hf name, field if field
-          name = field = nil
-          break
-
-        when /\AFrom (\S+)/
-          unixfrom = $1
-
-        when /^charset=.*/
-
-        else
-          raise SyntaxError, "wrong mail header: '#{line.inspect}'"
-        end
-      end
-      add_hf name, field if name
-
-      if unixfrom
-        add_hf 'Return-Path', "<#{unixfrom}>" unless @header['return-path']
-      end
-    end
-
-    def add_hf( name, field )
-      key = name.downcase
-      field = new_hf(name, field)
-
-      if ALLOW_MULTIPLE.include? key
-        (@header[key] ||= []).push field
-      else
-        @header[key] = field
-      end
-    end
-
-    def new_hf( name, field )
-      HeaderField.new(name, field, @config)
-    end
-
-    ###
-    ### body
-    ###
-
-    public
-
-    def body_port
-      parse_body
-      @body_port
-    end
-
-    def each( &block )
-      body_port().ropen {|f| f.each(&block) }
-    end
-
-    def quoted_body
-      body_port.ropen {|f| return f.read }
-    end
-
-    def quoted_body= str
-      body_port.wopen { |f| f.write str }
-      str
-    end
-
-    def body=( str )
-      # Sets the body of the email to a new (encoded) string.
-      # 
-      # We also reparses the email if the body is ever reassigned, this is a performance hit, however when
-      # you assign the body, you usually want to be able to make sure that you can access the attachments etc.
-      # 
-      # Usage:
-      # 
-      #  mail.body = "Hello, this is\nthe body text"
-      #  # => "Hello, this is\nthe body"
-      #  mail.body
-      #  # => "Hello, this is\nthe body"
-      @body_parsed = false
-      parse_body(StringInput.new(str))
-      parse_body
-      @body_port.wopen {|f| f.write str }
-      str
-    end
-
-    alias preamble  quoted_body
-    alias preamble= quoted_body=
-
-    def epilogue
-      parse_body
-      @epilogue.dup
-    end
-
-    def epilogue=( str )
-      parse_body
-      @epilogue = str
-      str
-    end
-
-    def parts
-      parse_body
-      @parts
-    end
-    
-    def each_part( &block )
-      parts().each(&block)
-    end
-    
-    # Returns true if the content type of this part of the email is
-    # a disposition attachment
-    def disposition_is_attachment?
-      (self['content-disposition'] && self['content-disposition'].disposition == "attachment")
-    end
-
-    # Returns true if this part's content main type is text, else returns false.
-    # By main type is meant "text/plain" is text.  "text/html" is text
-    def content_type_is_text?
-      self.header['content-type'] && (self.header['content-type'].main_type != "text")
-    end
-
-    private
-
-    def parse_body( f = nil )
-      return if @body_parsed
-      if f
-        parse_body_0 f
-      else
-        @port.ropen {|f|
-            skip_header f
-            parse_body_0 f
-        }
-      end
-      @body_parsed = true
-    end
-
-    def skip_header( f )
-      while line = f.gets
-        return if /\A[\r\n]*\z/ === line
-      end
-    end
-
-    def parse_body_0( f )
-      if multipart?
-        read_multipart f
-      else
-        @body_port = @config.new_body_port(self)
-        @body_port.wopen {|w|
-            w.write f.read
-        }
-      end
-    end
-    
-    def read_multipart( src )
-      bound = @header['content-type'].params['boundary']
-      is_sep = /\A--#{Regexp.quote bound}(?:--)?[ \t]*(?:\n|\r\n|\r)/
-      lastbound = "--#{bound}--"
-
-      ports = [ @config.new_preamble_port(self) ]
-      begin
-        f = ports.last.wopen
-        while line = src.gets
-          if is_sep === line
-            f.close
-            break if line.strip == lastbound
-            ports.push @config.new_part_port(self)
-            f = ports.last.wopen
-          else
-            f << line
-          end
-        end
-        @epilogue = (src.read || '')
-      ensure
-        f.close if f and not f.closed?
-      end
-
-      @body_port = ports.shift
-      @parts = ports.map {|p| self.class.new(p, @config) }
-    end
-
-  end   # class Mail
-
-end   # module TMail

actionmailer/lib/action_mailer/vendor/tmail-1.2.3/tmail/mailbox.rb

@@ -1,495 +0,0 @@
-=begin rdoc
-
-= Mailbox and Mbox interaction class
-
-=end
-#--
-# Copyright (c) 1998-2003 Minero Aoki <aamine@loveruby.net>
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-# Note: Originally licensed under LGPL v2+. Using MIT license for Rails
-# with permission of Minero Aoki.
-#++
-
-require 'tmail/port'
-require 'socket'
-require 'mutex_m'
-
-
-unless [].respond_to?(:sort_by)
-module Enumerable#:nodoc:
-  def sort_by
-    map {|i| [yield(i), i] }.sort {|a,b| a.first <=> b.first }.map {|i| i[1] }
-  end
-end
-end
-
-
-module TMail
-
-  class MhMailbox
-
-    PORT_CLASS = MhPort
-
-    def initialize( dir )
-      edir = File.expand_path(dir)
-      raise ArgumentError, "not directory: #{dir}"\
-                              unless FileTest.directory? edir
-      @dirname = edir
-      @last_file = nil
-      @last_atime = nil
-    end
-
-    def directory
-      @dirname
-    end
-
-    alias dirname directory
-
-    attr_accessor :last_atime
-
-    def inspect
-      "#<#{self.class} #{@dirname}>"
-    end
-
-    def close
-    end
-
-    def new_port
-      PORT_CLASS.new(next_file_name())
-    end
-
-    def each_port
-      mail_files().each do |path|
-        yield PORT_CLASS.new(path)
-      end
-      @last_atime = Time.now
-    end
-
-    alias each each_port
-
-    def reverse_each_port
-      mail_files().reverse_each do |path|
-        yield PORT_CLASS.new(path)
-      end
-      @last_atime = Time.now
-    end
-
-    alias reverse_each reverse_each_port
-
-    # old #each_mail returns Port
-    #def each_mail
-    #  each_port do |port|
-    #    yield Mail.new(port)
-    #  end
-    #end
-
-    def each_new_port( mtime = nil, &block )
-      mtime ||= @last_atime
-      return each_port(&block) unless mtime
-      return unless File.mtime(@dirname) >= mtime
-
-      mail_files().each do |path|
-        yield PORT_CLASS.new(path) if File.mtime(path) > mtime
-      end
-      @last_atime = Time.now
-    end
-
-    private
-
-    def mail_files
-      Dir.entries(@dirname)\
-              .select {|s| /\A\d+\z/ === s }\
-              .map {|s| s.to_i }\
-              .sort\
-              .map {|i| "#{@dirname}/#{i}" }\
-              .select {|path| FileTest.file? path }
-    end
-
-    def next_file_name
-      unless n = @last_file
-        n = 0
-        Dir.entries(@dirname)\
-                .select {|s| /\A\d+\z/ === s }\
-                .map {|s| s.to_i }.sort\
-        .each do |i|
-          next unless FileTest.file? "#{@dirname}/#{i}"
-          n = i
-        end
-      end
-      begin
-        n += 1
-      end while FileTest.exist? "#{@dirname}/#{n}"
-      @last_file = n
-
-      "#{@dirname}/#{n}"
-    end
-
-  end   # MhMailbox
-
-  MhLoader = MhMailbox
-
-
-  class UNIXMbox
-  
-    class << self
-      alias newobj new
-    end
-
-    # Creates a new mailbox object that you can iterate through to collect the
-    # emails from with "each_port".  
-    # 
-    # You need to pass it a filename of a unix mailbox format file, the format of this
-    # file can be researched at this page at {wikipedia}[link:http://en.wikipedia.org/wiki/Mbox]
-    # 
-    # ==== Parameters
-    # 
-    # +filename+: The filename of the mailbox you want to open
-    # 
-    # +tmpdir+: Can be set to override TMail using the system environment's temp dir. TMail will first
-    # use the temp dir specified by you (if any) or then the temp dir specified in the Environment's TEMP
-    # value then the value in the Environment's TMP value or failing all of the above, '/tmp'
-    # 
-    # +readonly+: If set to false, each email you take from the mail box will be removed from the mailbox.
-    # default is *false* - ie, it *WILL* truncate your mailbox file to ZERO once it has read the emails out.
-    # 
-    # ==== Options:
-    # 
-    # None
-    # 
-    # ==== Examples:
-    # 
-    #  # First show using readonly true:
-    # 
-    #  require 'ftools'
-    #  File.size("../test/fixtures/mailbox")
-    #  #=> 20426
-    #
-    #  mailbox = TMail::UNIXMbox.new("../test/fixtures/mailbox", nil, true) 
-    #  #=> #<TMail::UNIXMbox:0x14a2aa8 @readonly=true.....>
-    #
-    #  mailbox.each_port do |port| 
-    #    mail = TMail::Mail.new(port)
-    #    puts mail.subject
-    #  end
-    #  #Testing mailbox 1
-    #  #Testing mailbox 2
-    #  #Testing mailbox 3
-    #  #Testing mailbox 4
-    #  require 'ftools'
-    #  File.size?("../test/fixtures/mailbox")
-    #  #=> 20426
-    # 
-    #  # Now show with readonly set to the default false
-    # 
-    #  mailbox = TMail::UNIXMbox.new("../test/fixtures/mailbox") 
-    #  #=> #<TMail::UNIXMbox:0x14a2aa8 @readonly=false.....>
-    #
-    #  mailbox.each_port do |port| 
-    #    mail = TMail::Mail.new(port)
-    #    puts mail.subject
-    #  end
-    #  #Testing mailbox 1
-    #  #Testing mailbox 2
-    #  #Testing mailbox 3
-    #  #Testing mailbox 4
-    # 
-    #  File.size?("../test/fixtures/mailbox")
-    #  #=> nil
-    def UNIXMbox.new( filename, tmpdir = nil, readonly = false )
-      tmpdir = ENV['TEMP'] || ENV['TMP'] || '/tmp'
-      newobj(filename, "#{tmpdir}/ruby_tmail_#{$$}_#{rand()}", readonly, false)
-    end
-
-    def UNIXMbox.lock( fname )
-      begin
-        f = File.open(fname, 'r+')
-        f.flock File::LOCK_EX
-        yield f
-      ensure
-        f.flock File::LOCK_UN
-        f.close if f and not f.closed?
-      end
-    end
-
-    def UNIXMbox.static_new( fname, dir, readonly = false )
-      newobj(fname, dir, readonly, true)
-    end
-
-    def initialize( fname, mhdir, readonly, static )
-      @filename = fname
-      @readonly = readonly
-      @closed = false
-
-      Dir.mkdir mhdir
-      @real = MhMailbox.new(mhdir)
-      @finalizer = UNIXMbox.mkfinal(@real, @filename, !@readonly, !static)
-      ObjectSpace.define_finalizer self, @finalizer
-    end
-
-    def UNIXMbox.mkfinal( mh, mboxfile, writeback_p, cleanup_p )
-      lambda {
-          if writeback_p
-            lock(mboxfile) {|f|
-                mh.each_port do |port|
-                  f.puts create_from_line(port)
-                  port.ropen {|r|
-                      f.puts r.read
-                  }
-                end
-            }
-          end
-          if cleanup_p
-            Dir.foreach(mh.dirname) do |fname|
-              next if /\A\.\.?\z/ === fname
-              File.unlink "#{mh.dirname}/#{fname}"
-            end
-            Dir.rmdir mh.dirname
-          end
-      }
-    end
-
-    # make _From line
-    def UNIXMbox.create_from_line( port )
-      sprintf 'From %s %s',
-              fromaddr(), TextUtils.time2str(File.mtime(port.filename))
-    end
-
-    def UNIXMbox.fromaddr(port)
-      h = HeaderField.new_from_port(port, 'Return-Path') ||
-      HeaderField.new_from_port(port, 'From') ||
-      HeaderField.new_from_port(port, 'EnvelopeSender') or return 'nobody'
-      a = h.addrs[0] or return 'nobody'
-      a.spec
-    end
-
-    def close
-      return if @closed
-
-      ObjectSpace.undefine_finalizer self
-      @finalizer.call
-      @finalizer = nil
-      @real = nil
-      @closed = true
-      @updated = nil
-    end
-
-    def each_port( &block )
-      close_check
-      update
-      @real.each_port(&block)
-    end
-
-    alias each each_port
-
-    def reverse_each_port( &block )
-      close_check
-      update
-      @real.reverse_each_port(&block)
-    end
-
-    alias reverse_each reverse_each_port
-
-    # old #each_mail returns Port
-    #def each_mail( &block )
-    #  each_port do |port|
-    #    yield Mail.new(port)
-    #  end
-    #end
-
-    def each_new_port( mtime = nil )
-      close_check
-      update
-      @real.each_new_port(mtime) {|p| yield p }
-    end
-
-    def new_port
-      close_check
-      @real.new_port
-    end
-
-    private
-
-    def close_check
-      @closed and raise ArgumentError, 'accessing already closed mbox'
-    end
-
-    def update
-      return if FileTest.zero?(@filename)
-      return if @updated and File.mtime(@filename) < @updated
-      w = nil
-      port = nil
-      time = nil
-      UNIXMbox.lock(@filename) {|f|
-          begin
-            f.each do |line|
-              if /\AFrom / === line
-                w.close if w
-                File.utime time, time, port.filename if time
-
-                port = @real.new_port
-                w = port.wopen
-                time = fromline2time(line)
-              else
-                w.print line if w
-              end
-            end
-          ensure
-            if w and not w.closed?
-              w.close
-              File.utime time, time, port.filename if time
-            end
-          end
-          f.truncate(0) unless @readonly
-          @updated = Time.now
-      }
-    end
-
-    def fromline2time( line )
-      m = /\AFrom \S+ \w+ (\w+) (\d+) (\d+):(\d+):(\d+) (\d+)/.match(line) \
-              or return nil
-      Time.local(m[6].to_i, m[1], m[2].to_i, m[3].to_i, m[4].to_i, m[5].to_i)
-    end
-
-  end   # UNIXMbox
-
-  MboxLoader = UNIXMbox
-
-
-  class Maildir
-
-    extend Mutex_m
-
-    PORT_CLASS = MaildirPort
-
-    @seq = 0
-    def Maildir.unique_number
-      synchronize {
-          @seq += 1
-          return @seq
-      }
-    end
-
-    def initialize( dir = nil )
-      @dirname = dir || ENV['MAILDIR']
-      raise ArgumentError, "not directory: #{@dirname}"\
-                              unless FileTest.directory? @dirname
-      @new = "#{@dirname}/new"
-      @tmp = "#{@dirname}/tmp"
-      @cur = "#{@dirname}/cur"
-    end
-
-    def directory
-      @dirname
-    end
-
-    def inspect
-      "#<#{self.class} #{@dirname}>"
-    end
-
-    def close
-    end
-
-    def each_port
-      mail_files(@cur).each do |path|
-        yield PORT_CLASS.new(path)
-      end
-    end
-
-    alias each each_port
-
-    def reverse_each_port
-      mail_files(@cur).reverse_each do |path|
-        yield PORT_CLASS.new(path)
-      end
-    end
-
-    alias reverse_each reverse_each_port
-
-    def new_port
-      fname = nil
-      tmpfname = nil
-      newfname = nil
-
-      begin
-        fname = "#{Time.now.to_i}.#{$$}_#{Maildir.unique_number}.#{Socket.gethostname}"
-        
-        tmpfname = "#{@tmp}/#{fname}"
-        newfname = "#{@new}/#{fname}"
-      end while FileTest.exist? tmpfname
-
-      if block_given?
-        File.open(tmpfname, 'w') {|f| yield f }
-        File.rename tmpfname, newfname
-        PORT_CLASS.new(newfname)
-      else
-        File.open(tmpfname, 'w') {|f| f.write "\n\n" }
-        PORT_CLASS.new(tmpfname)
-      end
-    end
-
-    def each_new_port
-      mail_files(@new).each do |path|
-        dest = @cur + '/' + File.basename(path)
-        File.rename path, dest
-        yield PORT_CLASS.new(dest)
-      end
-
-      check_tmp
-    end
-
-    TOO_OLD = 60 * 60 * 36   # 36 hour
-
-    def check_tmp
-      old = Time.now.to_i - TOO_OLD
-      
-      each_filename(@tmp) do |full, fname|
-        if FileTest.file? full and
-           File.stat(full).mtime.to_i < old
-          File.unlink full
-        end
-      end
-    end
-
-    private
-
-    def mail_files( dir )
-      Dir.entries(dir)\
-              .select {|s| s[0] != ?. }\
-              .sort_by {|s| s.slice(/\A\d+/).to_i }\
-              .map {|s| "#{dir}/#{s}" }\
-              .select {|path| FileTest.file? path }
-    end
-
-    def each_filename( dir )
-      Dir.foreach(dir) do |fname|
-        path = "#{dir}/#{fname}"
-        if fname[0] != ?. and FileTest.file? path
-          yield path, fname
-        end
-      end
-    end
-    
-  end   # Maildir
-
-  MaildirLoader = Maildir
-
-end   # module TMail

actionmailer/lib/action_mailer/vendor/tmail-1.2.3/tmail/main.rb

@@ -1,6 +0,0 @@
-#:stopdoc:
-require 'tmail/version'
-require 'tmail/mail'
-require 'tmail/mailbox'
-require 'tmail/core_extensions'
-#:startdoc:

actionmailer/lib/action_mailer/vendor/tmail-1.2.3/tmail/mbox.rb

@@ -1,3 +0,0 @@
-#:stopdoc:
-require 'tmail/mailbox'
-#:startdoc:

actionmailer/lib/action_mailer/vendor/tmail-1.2.3/tmail/net.rb

@@ -1,248 +0,0 @@
-#--
-# Copyright (c) 1998-2003 Minero Aoki <aamine@loveruby.net>
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-# Note: Originally licensed under LGPL v2+. Using MIT license for Rails
-# with permission of Minero Aoki.
-#++
-
-#:stopdoc:
-require 'nkf'
-#:startdoc:
-
-module TMail
-
-  class Mail
-    
-    def send_to( smtp )
-      do_send_to(smtp) do
-        ready_to_send
-      end
-    end
-
-    def send_text_to( smtp )
-      do_send_to(smtp) do
-        ready_to_send
-        mime_encode
-      end
-    end
-
-    def do_send_to( smtp )
-      from = from_address or raise ArgumentError, 'no from address'
-      (dests = destinations).empty? and raise ArgumentError, 'no receipient'
-      yield
-      send_to_0 smtp, from, dests
-    end
-    private :do_send_to
-
-    def send_to_0( smtp, from, to )
-      smtp.ready(from, to) do |f|
-        encoded "\r\n", 'j', f, ''
-      end
-    end
-
-    def ready_to_send
-      delete_no_send_fields
-      add_message_id
-      add_date
-    end
-
-    NOSEND_FIELDS = %w(
-      received
-      bcc
-    )
-
-    def delete_no_send_fields
-      NOSEND_FIELDS.each do |nm|
-        delete nm
-      end
-      delete_if {|n,v| v.empty? }
-    end
-
-    def add_message_id( fqdn = nil )
-      self.message_id = ::TMail::new_message_id(fqdn)
-    end
-
-    def add_date
-      self.date = Time.now
-    end
-
-    def mime_encode
-      if parts.empty?
-        mime_encode_singlepart
-      else
-        mime_encode_multipart true
-      end
-    end
-
-    def mime_encode_singlepart
-      self.mime_version = '1.0'
-      b = body
-      if NKF.guess(b) != NKF::BINARY
-        mime_encode_text b
-      else
-        mime_encode_binary b
-      end
-    end
-
-    def mime_encode_text( body )
-      self.body = NKF.nkf('-j -m0', body)
-      self.set_content_type 'text', 'plain', {'charset' => 'iso-2022-jp'}
-      self.encoding = '7bit'
-    end
-
-    def mime_encode_binary( body )
-      self.body = [body].pack('m')
-      self.set_content_type 'application', 'octet-stream'
-      self.encoding = 'Base64'
-    end
-
-    def mime_encode_multipart( top = true )
-      self.mime_version = '1.0' if top
-      self.set_content_type 'multipart', 'mixed'
-      e = encoding(nil)
-      if e and not /\A(?:7bit|8bit|binary)\z/i === e
-        raise ArgumentError,
-              'using C.T.Encoding with multipart mail is not permitted'
-      end
-    end
-  
-  end
-
-  #:stopdoc:
-  class DeleteFields
-
-    NOSEND_FIELDS = %w(
-      received
-      bcc
-    )
-
-    def initialize( nosend = nil, delempty = true )
-      @no_send_fields = nosend || NOSEND_FIELDS.dup
-      @delete_empty_fields = delempty
-    end
-
-    attr :no_send_fields
-    attr :delete_empty_fields, true
-
-    def exec( mail )
-      @no_send_fields.each do |nm|
-        delete nm
-      end
-      delete_if {|n,v| v.empty? } if @delete_empty_fields
-    end
-  
-  end
-  #:startdoc:
-
-  #:stopdoc:
-  class AddMessageId
-
-    def initialize( fqdn = nil )
-      @fqdn = fqdn
-    end
-
-    attr :fqdn, true
-
-    def exec( mail )
-      mail.message_id = ::TMail::new_msgid(@fqdn)
-    end
-  
-  end
-  #:startdoc:
-
-  #:stopdoc:
-  class AddDate
-
-    def exec( mail )
-      mail.date = Time.now
-    end
-  
-  end
-  #:startdoc:
-
-  #:stopdoc:
-  class MimeEncodeAuto
-
-    def initialize( s = nil, m = nil )
-      @singlepart_composer = s || MimeEncodeSingle.new
-      @multipart_composer  = m || MimeEncodeMulti.new
-    end
-
-    attr :singlepart_composer
-    attr :multipart_composer
-
-    def exec( mail )
-      if mail._builtin_multipart?
-      then @multipart_composer
-      else @singlepart_composer end.exec mail
-    end
-  
-  end
-  #:startdoc:
-  
-  #:stopdoc:
-  class MimeEncodeSingle
-
-    def exec( mail )
-      mail.mime_version = '1.0'
-      b = mail.body
-      if NKF.guess(b) != NKF::BINARY
-        on_text b
-      else
-        on_binary b
-      end
-    end
-
-    def on_text( body )
-      mail.body = NKF.nkf('-j -m0', body)
-      mail.set_content_type 'text', 'plain', {'charset' => 'iso-2022-jp'}
-      mail.encoding = '7bit'
-    end
-
-    def on_binary( body )
-      mail.body = [body].pack('m')
-      mail.set_content_type 'application', 'octet-stream'
-      mail.encoding = 'Base64'
-    end
-  
-  end
-  #:startdoc:
-  
-  #:stopdoc:
-  class MimeEncodeMulti
-
-    def exec( mail, top = true )
-      mail.mime_version = '1.0' if top
-      mail.set_content_type 'multipart', 'mixed'
-      e = encoding(nil)
-      if e and not /\A(?:7bit|8bit|binary)\z/i === e
-        raise ArgumentError,
-              'using C.T.Encoding with multipart mail is not permitted'
-      end
-      mail.parts.each do |m|
-        exec m, false if m._builtin_multipart?
-      end
-    end
-
-  end
-  #:startdoc:
-end   # module TMail

actionmailer/lib/action_mailer/vendor/tmail-1.2.3/tmail/obsolete.rb

@@ -1,132 +0,0 @@
-=begin rdoc
-
-= Obsolete methods that are depriciated
-
-If you really want to see them, go to lib/tmail/obsolete.rb and view to your
-heart's content.
-
-=end
-#--
-# Copyright (c) 1998-2003 Minero Aoki <aamine@loveruby.net>
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-# Note: Originally licensed under LGPL v2+. Using MIT license for Rails
-# with permission of Minero Aoki.
-#++
-#:stopdoc:
-module TMail #:nodoc:
-
-  class Mail
-    alias include? key?
-    alias has_key? key?
-
-    def values
-      ret = []
-      each_field {|v| ret.push v }
-      ret
-    end
-
-    def value?( val )
-      HeaderField === val or return false
-
-      [ @header[val.name.downcase] ].flatten.include? val
-    end
-
-    alias has_value? value?
-  end
-
-  class Mail
-    def from_addr( default = nil )
-      addr, = from_addrs(nil)
-      addr || default
-    end
-
-    def from_address( default = nil )
-      if a = from_addr(nil)
-        a.spec
-      else
-        default
-      end
-    end
-
-    alias from_address= from_addrs=
-
-    def from_phrase( default = nil )
-      if a = from_addr(nil)
-        a.phrase
-      else
-        default
-      end
-    end
-
-    alias msgid  message_id
-    alias msgid= message_id=
-
-    alias each_dest each_destination
-  end
-
-  class Address
-    alias route routes
-    alias addr spec
-
-    def spec=( str ) 
-      @local, @domain = str.split(/@/,2).map {|s| s.split(/\./) }
-    end
-
-    alias addr= spec=
-    alias address= spec=
-  end
-
-  class MhMailbox
-    alias new_mail new_port
-    alias each_mail each_port
-    alias each_newmail each_new_port
-  end
-  class UNIXMbox
-    alias new_mail new_port
-    alias each_mail each_port
-    alias each_newmail each_new_port
-  end
-  class Maildir
-    alias new_mail new_port
-    alias each_mail each_port
-    alias each_newmail each_new_port
-  end
-
-  extend TextUtils
-
-  class << self
-    alias msgid?    message_id?
-    alias boundary  new_boundary
-    alias msgid     new_message_id
-    alias new_msgid new_message_id
-  end
-
-  def Mail.boundary
-    ::TMail.new_boundary
-  end
-
-  def Mail.msgid
-    ::TMail.new_message_id
-  end
-
-end   # module TMail
-#:startdoc:

actionmailer/lib/action_mailer/vendor/tmail-1.2.3/tmail/port.rb

@@ -1,379 +0,0 @@
-=begin rdoc
-
-= Port class
-
-=end
-#--
-# Copyright (c) 1998-2003 Minero Aoki <aamine@loveruby.net>
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-# Note: Originally licensed under LGPL v2+. Using MIT license for Rails
-# with permission of Minero Aoki.
-#++
-
-require 'tmail/stringio'
-
-
-module TMail
-
-  class Port
-    def reproducible?
-      false
-    end
-  end
-
-
-  ###
-  ### FilePort
-  ###
-
-  class FilePort < Port
-
-    def initialize( fname )
-      @filename = File.expand_path(fname)
-      super()
-    end
-
-    attr_reader :filename
-
-    alias ident filename
-
-    def ==( other )
-      other.respond_to?(:filename) and @filename == other.filename
-    end
-
-    alias eql? ==
-
-    def hash
-      @filename.hash
-    end
-
-    def inspect
-      "#<#{self.class}:#{@filename}>"
-    end
-
-    def reproducible?
-      true
-    end
-
-    def size
-      File.size @filename
-    end
-
-
-    def ropen( &block )
-      File.open(@filename, &block)
-    end
-
-    def wopen( &block )
-      File.open(@filename, 'w', &block)
-    end
-
-    def aopen( &block )
-      File.open(@filename, 'a', &block)
-    end
-
-
-    def read_all
-      ropen {|f|
-          return f.read
-      }
-    end
-
-
-    def remove
-      File.unlink @filename
-    end
-
-    def move_to( port )
-      begin
-        File.link @filename, port.filename
-      rescue Errno::EXDEV
-        copy_to port
-      end
-      File.unlink @filename
-    end
-
-    alias mv move_to
-
-    def copy_to( port )
-      if FilePort === port
-        copy_file @filename, port.filename
-      else
-        File.open(@filename) {|r|
-        port.wopen {|w|
-            while s = r.sysread(4096)
-              w.write << s
-            end
-        } }
-      end
-    end
-
-    alias cp copy_to
-
-    private
-
-    # from fileutils.rb
-    def copy_file( src, dest )
-      st = r = w = nil
-
-      File.open(src,  'rb') {|r|
-      File.open(dest, 'wb') {|w|
-          st = r.stat
-          begin
-            while true
-              w.write r.sysread(st.blksize)
-            end
-          rescue EOFError
-          end
-      } }
-    end
-
-  end
-
-
-  module MailFlags
-
-    def seen=( b )
-      set_status 'S', b
-    end
-
-    def seen?
-      get_status 'S'
-    end
-
-    def replied=( b )
-      set_status 'R', b
-    end
-
-    def replied?
-      get_status 'R'
-    end
-
-    def flagged=( b )
-      set_status 'F', b
-    end
-
-    def flagged?
-      get_status 'F'
-    end
-
-    private
-
-    def procinfostr( str, tag, true_p )
-      a = str.upcase.split(//)
-      a.push true_p ? tag : nil
-      a.delete tag unless true_p
-      a.compact.sort.join('').squeeze
-    end
-  
-  end
-
-
-  class MhPort < FilePort
-
-    include MailFlags
-
-    private
-    
-    def set_status( tag, flag )
-      begin
-        tmpfile = @filename + '.tmailtmp.' + $$.to_s
-        File.open(tmpfile, 'w') {|f|
-          write_status f, tag, flag
-        }
-        File.unlink @filename
-        File.link tmpfile, @filename
-      ensure
-        File.unlink tmpfile
-      end
-    end
-
-    def write_status( f, tag, flag )
-      stat = ''
-      File.open(@filename) {|r|
-        while line = r.gets
-          if line.strip.empty?
-            break
-          elsif m = /\AX-TMail-Status:/i.match(line)
-            stat = m.post_match.strip
-          else
-            f.print line
-          end
-        end
-
-        s = procinfostr(stat, tag, flag)
-        f.puts 'X-TMail-Status: ' + s unless s.empty?
-        f.puts
-
-        while s = r.read(2048)
-          f.write s
-        end
-      }
-    end
-
-    def get_status( tag )
-      File.foreach(@filename) {|line|
-        return false if line.strip.empty?
-        if m = /\AX-TMail-Status:/i.match(line)
-          return m.post_match.strip.include?(tag[0])
-        end
-      }
-      false
-    end
-  
-  end
-
-
-  class MaildirPort < FilePort
-
-    def move_to_new
-      new = replace_dir(@filename, 'new')
-      File.rename @filename, new
-      @filename = new
-    end
-
-    def move_to_cur
-      new = replace_dir(@filename, 'cur')
-      File.rename @filename, new
-      @filename = new
-    end
-
-    def replace_dir( path, dir )
-      "#{File.dirname File.dirname(path)}/#{dir}/#{File.basename path}"
-    end
-    private :replace_dir
-
-
-    include MailFlags
-
-    private
-
-    MAIL_FILE = /\A(\d+\.[\d_]+\.[^:]+)(?:\:(\d),(\w+)?)?\z/
-
-    def set_status( tag, flag )
-      if m = MAIL_FILE.match(File.basename(@filename))
-        s, uniq, type, info, = m.to_a
-        return if type and type != '2'  # do not change anything
-        newname = File.dirname(@filename) + '/' +
-                  uniq + ':2,' + procinfostr(info.to_s, tag, flag)
-      else
-        newname = @filename + ':2,' + tag
-      end
-
-      File.link @filename, newname
-      File.unlink @filename
-      @filename = newname
-    end
-
-    def get_status( tag )
-      m = MAIL_FILE.match(File.basename(@filename)) or return false
-      m[2] == '2' and m[3].to_s.include?(tag[0])
-    end
-  
-  end
-
-
-  ###
-  ###  StringPort
-  ###
-
-  class StringPort < Port
-
-    def initialize( str = '' )
-      @buffer = str
-      super()
-    end
-
-    def string
-      @buffer
-    end
-
-    def to_s
-      @buffer.dup
-    end
-
-    alias read_all to_s
-
-    def size
-      @buffer.size
-    end
-
-    def ==( other )
-      StringPort === other and @buffer.equal? other.string
-    end
-
-    alias eql? ==
-
-    def hash
-      @buffer.object_id.hash
-    end
-
-    def inspect
-      "#<#{self.class}:id=#{sprintf '0x%x', @buffer.object_id}>"
-    end
-
-    def reproducible?
-      true
-    end
-
-    def ropen( &block )
-      @buffer or raise Errno::ENOENT, "#{inspect} is already removed"
-      StringInput.open(@buffer, &block)
-    end
-
-    def wopen( &block )
-      @buffer = ''
-      StringOutput.new(@buffer, &block)
-    end
-
-    def aopen( &block )
-      @buffer ||= ''
-      StringOutput.new(@buffer, &block)
-    end
-
-    def remove
-      @buffer = nil
-    end
-
-    alias rm remove
-
-    def copy_to( port )
-      port.wopen {|f|
-          f.write @buffer
-      }
-    end
-
-    alias cp copy_to
-
-    def move_to( port )
-      if StringPort === port
-        str = @buffer
-        port.instance_eval { @buffer = str }
-      else
-        copy_to port
-      end
-      remove
-    end
-
-  end
-
-end   # module TMail

actionmailer/lib/action_mailer/vendor/tmail-1.2.3/tmail/quoting.rb

@@ -1,118 +0,0 @@
-=begin rdoc
-
-= Quoting methods
-
-=end
-module TMail
-  class Mail
-    def subject(to_charset = 'utf-8')
-      Unquoter.unquote_and_convert_to(quoted_subject, to_charset)
-    end
-
-    def unquoted_body(to_charset = 'utf-8')
-      from_charset = sub_header("content-type", "charset")
-      case (content_transfer_encoding || "7bit").downcase
-        when "quoted-printable"
-          # the default charset is set to iso-8859-1 instead of 'us-ascii'.
-          # This is needed as many mailer do not set the charset but send in ISO. This is only used if no charset is set.
-          if !from_charset.blank? && from_charset.downcase == 'us-ascii'
-            from_charset = 'iso-8859-1'
-          end
-
-          Unquoter.unquote_quoted_printable_and_convert_to(quoted_body,
-            to_charset, from_charset, true)
-        when "base64"
-          Unquoter.unquote_base64_and_convert_to(quoted_body, to_charset,
-            from_charset)
-        when "7bit", "8bit"
-          Unquoter.convert_to(quoted_body, to_charset, from_charset)
-        when "binary"
-          quoted_body
-        else
-          quoted_body
-      end
-    end
-
-    def body(to_charset = 'utf-8', &block)
-      attachment_presenter = block || Proc.new { |file_name| "Attachment: #{file_name}\n" }
-
-      if multipart?
-        parts.collect { |part|
-          header = part["content-type"]
-
-          if part.multipart?
-            part.body(to_charset, &attachment_presenter)
-          elsif header.nil?
-            ""
-          elsif !attachment?(part)
-            part.unquoted_body(to_charset)
-          else
-            attachment_presenter.call(header["name"] || "(unnamed)")
-          end
-        }.join
-      else
-        unquoted_body(to_charset)
-      end
-    end
-  end
-
-  class Unquoter
-    class << self
-      def unquote_and_convert_to(text, to_charset, from_charset = "iso-8859-1", preserve_underscores=false)
-        return "" if text.nil?
-        text.gsub(/(.*?)(?:(?:=\?(.*?)\?(.)\?(.*?)\?=)|$)/) do
-          before = $1
-          from_charset = $2
-          quoting_method = $3
-          text = $4
-
-          before = convert_to(before, to_charset, from_charset) if before.length > 0
-          before + case quoting_method
-              when "q", "Q" then
-                unquote_quoted_printable_and_convert_to(text, to_charset, from_charset, preserve_underscores)
-              when "b", "B" then
-                unquote_base64_and_convert_to(text, to_charset, from_charset)
-              when nil then
-                # will be nil at the end of the string, due to the nature of
-                # the regex used.
-                ""
-              else
-                raise "unknown quoting method #{quoting_method.inspect}"
-            end
-        end
-      end
-
-      def unquote_quoted_printable_and_convert_to(text, to, from, preserve_underscores=false)
-        text = text.gsub(/_/, " ") unless preserve_underscores
-        text = text.gsub(/\r\n|\r/, "\n") # normalize newlines
-        convert_to(text.unpack("M*").first, to, from)
-      end
-
-      def unquote_base64_and_convert_to(text, to, from)
-        convert_to(Base64.decode(text), to, from)
-      end
-
-      begin
-        require 'iconv'
-        def convert_to(text, to, from)
-          return text unless to && from
-          text ? Iconv.iconv(to, from, text).first : ""
-        rescue Iconv::IllegalSequence, Iconv::InvalidEncoding, Errno::EINVAL
-          # the 'from' parameter specifies a charset other than what the text
-          # actually is...not much we can do in this case but just return the
-          # unconverted text.
-          #
-          # Ditto if either parameter represents an unknown charset, like
-          # X-UNKNOWN.
-          text
-        end
-      rescue LoadError
-        # Not providing quoting support
-        def convert_to(text, to, from)
-          warn "Action Mailer: iconv not loaded; ignoring conversion from #{from} to #{to} (#{__FILE__}:#{__LINE__})"
-          text
-        end
-      end
-    end
-  end
-end

actionmailer/lib/action_mailer/vendor/tmail-1.2.3/tmail/require_arch.rb

@@ -1,58 +0,0 @@
-#:stopdoc:
-require 'rbconfig'
-
-# Attempts to require anative extension.
-# Falls back to pure-ruby version, if it fails.
-#
-# This uses Config::CONFIG['arch'] from rbconfig.
-
-def require_arch(fname)
-  arch = Config::CONFIG['arch']
-  begin
-    path = File.join("tmail", arch, fname)
-    require path
-  rescue LoadError => e
-    # try pre-built Windows binaries
-    if arch =~ /mswin/
-      require File.join("tmail", 'mswin32', fname)
-    else
-      raise e
-    end
-  end
-end
-
-
-# def require_arch(fname)
-#   dext = Config::CONFIG['DLEXT']
-#   begin
-#     if File.extname(fname) == dext
-#       path = fname
-#     else
-#       path = File.join("tmail","#{fname}.#{dext}")
-#     end
-#     require path
-#   rescue LoadError => e
-#     begin
-#       arch = Config::CONFIG['arch']
-#       path = File.join("tmail", arch, "#{fname}.#{dext}")
-#       require path
-#     rescue LoadError
-#       case path
-#       when /i686/
-#         path.sub!('i686', 'i586')
-#       when /i586/
-#         path.sub!('i586', 'i486')
-#       when /i486/
-#         path.sub!('i486', 'i386')
-#       else
-#         begin
-#           require fname + '.rb'
-#         rescue LoadError
-#           raise e
-#         end
-#       end
-#       retry
-#     end
-#   end
-# end
-#:startdoc:

actionmailer/lib/action_mailer/vendor/tmail-1.2.3/tmail/scanner.rb

@@ -1,49 +0,0 @@
-=begin rdoc
-
-= Scanner for TMail
-
-=end
-#--
-# Copyright (c) 1998-2003 Minero Aoki <aamine@loveruby.net>
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-# Note: Originally licensed under LGPL v2+. Using MIT license for Rails
-# with permission of Minero Aoki.
-#++
-#:stopdoc:
-#require 'tmail/require_arch'
-require 'tmail/utils'
-require 'tmail/config'
-
-module TMail
-  # NOTE: It woiuld be nice if these two libs could boith be called "tmailscanner", and
-  # the native extension would have precedence. However RubyGems boffs that up b/c
-  # it does not gaurantee load_path order.
-  begin
-    raise LoadError, 'Turned off native extentions by user choice' if ENV['NORUBYEXT']
-    require('tmail/tmailscanner') # c extension
-    Scanner = TMailScanner
-  rescue LoadError
-    require 'tmail/scanner_r'
-    Scanner = TMailScanner
-  end
-end
-#:stopdoc:

actionmailer/lib/action_mailer/vendor/tmail-1.2.3/tmail/scanner_r.rb

@@ -1,261 +0,0 @@
-# scanner_r.rb
-#
-#--
-# Copyright (c) 1998-2003 Minero Aoki <aamine@loveruby.net>
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-# Note: Originally licensed under LGPL v2+. Using MIT license for Rails
-# with permission of Minero Aoki.
-#++
-#:stopdoc:
-require 'tmail/config'
-
-module TMail
-
-  class TMailScanner
-
-    Version = '1.2.3'
-    Version.freeze
-
-    MIME_HEADERS = {
-      :CTYPE        => true,
-      :CENCODING    => true,
-      :CDISPOSITION => true
-    }
-
-    alnum      = 'a-zA-Z0-9'
-    atomsyms   = %q[  _#!$%&`'*+-{|}~^/=?  ].strip
-    tokensyms  = %q[  _#!$%&`'*+-{|}~^@.    ].strip
-    atomchars  = alnum + Regexp.quote(atomsyms)
-    tokenchars = alnum + Regexp.quote(tokensyms)
-    iso2022str = '\e(?!\(B)..(?:[^\e]+|\e(?!\(B)..)*\e\(B'
-
-    eucstr  = "(?:[\xa1-\xfe][\xa1-\xfe])+"
-    sjisstr = "(?:[\x81-\x9f\xe0-\xef][\x40-\x7e\x80-\xfc])+"
-    utf8str = "(?:[\xc0-\xdf][\x80-\xbf]|[\xe0-\xef][\x80-\xbf][\x80-\xbf])+"
-
-    quoted_with_iso2022  = /\A(?:[^\\\e"]+|#{iso2022str})+/n
-    domlit_with_iso2022  = /\A(?:[^\\\e\]]+|#{iso2022str})+/n
-    comment_with_iso2022 = /\A(?:[^\\\e()]+|#{iso2022str})+/n
-
-    quoted_without_iso2022  = /\A[^\\"]+/n
-    domlit_without_iso2022  = /\A[^\\\]]+/n
-    comment_without_iso2022 = /\A[^\\()]+/n
-
-    PATTERN_TABLE = {}
-    PATTERN_TABLE['EUC'] =
-      [
-        /\A(?:[#{atomchars}]+|#{iso2022str}|#{eucstr})+/n,
-        /\A(?:[#{tokenchars}]+|#{iso2022str}|#{eucstr})+/n,
-        quoted_with_iso2022,
-        domlit_with_iso2022,
-        comment_with_iso2022
-      ]
-    PATTERN_TABLE['SJIS'] =
-      [
-        /\A(?:[#{atomchars}]+|#{iso2022str}|#{sjisstr})+/n,
-        /\A(?:[#{tokenchars}]+|#{iso2022str}|#{sjisstr})+/n,
-        quoted_with_iso2022,
-        domlit_with_iso2022,
-        comment_with_iso2022
-      ]
-    PATTERN_TABLE['UTF8'] =
-      [
-        /\A(?:[#{atomchars}]+|#{utf8str})+/n,
-        /\A(?:[#{tokenchars}]+|#{utf8str})+/n,
-        quoted_without_iso2022,
-        domlit_without_iso2022,
-        comment_without_iso2022
-      ]
-    PATTERN_TABLE['NONE'] =
-      [
-        /\A[#{atomchars}]+/n,
-        /\A[#{tokenchars}]+/n,
-        quoted_without_iso2022,
-        domlit_without_iso2022,
-        comment_without_iso2022
-      ]
-
-
-    def initialize( str, scantype, comments )
-      init_scanner str
-      @comments = comments || []
-      @debug    = false
-
-      # fix scanner mode
-      @received  = (scantype == :RECEIVED)
-      @is_mime_header = MIME_HEADERS[scantype]
-
-      atom, token, @quoted_re, @domlit_re, @comment_re = PATTERN_TABLE[TMail.KCODE]
-      @word_re = (MIME_HEADERS[scantype] ? token : atom)
-    end
-
-    attr_accessor :debug
-
-    def scan( &block )
-      if @debug
-        scan_main do |arr|
-          s, v = arr
-          printf "%7d %-10s %s\n",
-                 rest_size(),
-                 s.respond_to?(:id2name) ? s.id2name : s.inspect,
-                 v.inspect
-          yield arr
-        end
-      else
-        scan_main(&block)
-      end
-    end
-
-    private
-
-    RECV_TOKEN = {
-      'from' => :FROM,
-      'by'   => :BY,
-      'via'  => :VIA,
-      'with' => :WITH,
-      'id'   => :ID,
-      'for'  => :FOR
-    }
-
-    def scan_main
-      until eof?
-        if skip(/\A[\n\r\t ]+/n)   # LWSP
-          break if eof?
-        end
-
-        if s = readstr(@word_re)
-          if @is_mime_header
-            yield [:TOKEN, s]
-          else
-            # atom
-            if /\A\d+\z/ === s
-              yield [:DIGIT, s]
-            elsif @received
-              yield [RECV_TOKEN[s.downcase] || :ATOM, s]
-            else
-              yield [:ATOM, s]
-            end
-          end
-
-        elsif skip(/\A"/)
-          yield [:QUOTED, scan_quoted_word()]
-
-        elsif skip(/\A\[/)
-          yield [:DOMLIT, scan_domain_literal()]
-
-        elsif skip(/\A\(/)
-          @comments.push scan_comment()
-
-        else
-          c = readchar()
-          yield [c, c]
-        end
-      end
-
-      yield [false, '$']
-    end
-
-    def scan_quoted_word
-      scan_qstr(@quoted_re, /\A"/, 'quoted-word')
-    end
-
-    def scan_domain_literal
-      '[' + scan_qstr(@domlit_re, /\A\]/, 'domain-literal') + ']'
-    end
-
-    def scan_qstr( pattern, terminal, type )
-      result = ''
-      until eof?
-        if    s = readstr(pattern) then result << s
-        elsif skip(terminal)       then return result
-        elsif skip(/\A\\/)         then result << readchar()
-        else
-          raise "TMail FATAL: not match in #{type}"
-        end
-      end
-      scan_error! "found unterminated #{type}"
-    end
-
-    def scan_comment
-      result = ''
-      nest = 1
-      content = @comment_re
-
-      until eof?
-        if s = readstr(content) then result << s
-        elsif skip(/\A\)/)      then nest -= 1
-                                     return result if nest == 0
-                                     result << ')'
-        elsif skip(/\A\(/)      then nest += 1
-                                     result << '('
-        elsif skip(/\A\\/)      then result << readchar()
-        else
-          raise 'TMail FATAL: not match in comment'
-        end
-      end
-      scan_error! 'found unterminated comment'
-    end
-
-    # string scanner
-
-    def init_scanner( str )
-      @src = str
-    end
-
-    def eof?
-      @src.empty?
-    end
-
-    def rest_size
-      @src.size
-    end
-
-    def readstr( re )
-      if m = re.match(@src)
-        @src = m.post_match
-        m[0]
-      else
-        nil
-      end
-    end
-
-    def readchar
-      readstr(/\A./)
-    end
-
-    def skip( re )
-      if m = re.match(@src)
-        @src = m.post_match
-        true
-      else
-        false
-      end
-    end
-
-    def scan_error!( msg )
-      raise SyntaxError, msg
-    end
-
-  end
-
-end   # module TMail
-#:startdoc:

actionmailer/lib/action_mailer/vendor/tmail-1.2.3/tmail/stringio.rb

@@ -1,280 +0,0 @@
-# encoding: utf-8
-=begin rdoc
-
-= String handling class
-
-=end
-#--
-# Copyright (c) 1998-2003 Minero Aoki <aamine@loveruby.net>
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-# Note: Originally licensed under LGPL v2+. Using MIT license for Rails
-# with permission of Minero Aoki.
-#++
-
-class StringInput#:nodoc:
-
-  include Enumerable
-
-  class << self
-
-    def new( str )
-      if block_given?
-        begin
-          f = super
-          yield f
-        ensure
-          f.close if f
-        end
-      else
-        super
-      end
-    end
-
-    alias open new
-  
-  end
-
-  def initialize( str )
-    @src = str
-    @pos = 0
-    @closed = false
-    @lineno = 0
-  end
-
-  attr_reader :lineno
-
-  def string
-    @src
-  end
-
-  def inspect
-    "#<#{self.class}:#{@closed ? 'closed' : 'open'},src=#{@src[0,30].inspect}>"
-  end
-
-  def close
-    stream_check!
-    @pos = nil
-    @closed = true
-  end
-
-  def closed?
-    @closed
-  end
-
-  def pos
-    stream_check!
-    [@pos, @src.size].min
-  end
-
-  alias tell pos
-
-  def seek( offset, whence = IO::SEEK_SET )
-    stream_check!
-    case whence
-    when IO::SEEK_SET
-      @pos = offset
-    when IO::SEEK_CUR
-      @pos += offset
-    when IO::SEEK_END
-      @pos = @src.size - offset
-    else
-      raise ArgumentError, "unknown seek flag: #{whence}"
-    end
-    @pos = 0 if @pos < 0
-    @pos = [@pos, @src.size + 1].min
-    offset
-  end
-
-  def rewind
-    stream_check!
-    @pos = 0
-  end
-
-  def eof?
-    stream_check!
-    @pos > @src.size
-  end
-
-  def each( &block )
-    stream_check!
-    begin
-      @src.each(&block)
-    ensure
-      @pos = 0
-    end
-  end
-
-  def gets
-    stream_check!
-    if idx = @src.index(?\n, @pos)
-      idx += 1  # "\n".size
-      line = @src[ @pos ... idx ]
-      @pos = idx
-      @pos += 1 if @pos == @src.size
-    else
-      line = @src[ @pos .. -1 ]
-      @pos = @src.size + 1
-    end
-    @lineno += 1
-
-    line
-  end
-
-  def getc
-    stream_check!
-    ch = @src[@pos]
-    @pos += 1
-    @pos += 1 if @pos == @src.size
-    ch
-  end
-
-  def read( len = nil )
-    stream_check!
-    return read_all unless len
-    str = @src[@pos, len]
-    @pos += len
-    @pos += 1 if @pos == @src.size
-    str
-  end
-
-  alias sysread read
-
-  def read_all
-    stream_check!
-    return nil if eof?
-    rest = @src[@pos ... @src.size]
-    @pos = @src.size + 1
-    rest
-  end
-
-  def stream_check!
-    @closed and raise IOError, 'closed stream'
-  end
-
-end
-
-
-class StringOutput#:nodoc:
-
-  class << self
-
-    def new( str = '' )
-      if block_given?
-        begin
-          f = super
-          yield f
-        ensure
-          f.close if f
-        end
-      else
-        super
-      end
-    end
-
-    alias open new
-  
-  end
-
-  def initialize( str = '' )
-    @dest = str
-    @closed = false
-  end
-
-  def close
-    @closed = true
-  end
-
-  def closed?
-    @closed
-  end
-
-  def string
-    @dest
-  end
-
-  alias value string
-  alias to_str string
-
-  def size
-    @dest.size
-  end
-
-  alias pos size
-
-  def inspect
-    "#<#{self.class}:#{@dest ? 'open' : 'closed'},#{object_id}>"
-  end
-
-  def print( *args )
-    stream_check!
-    raise ArgumentError, 'wrong # of argument (0 for >1)' if args.empty?
-    args.each do |s|
-      raise ArgumentError, 'nil not allowed' if s.nil?
-      @dest << s.to_s
-    end
-    nil
-  end
-
-  def puts( *args )
-    stream_check!
-    args.each do |str|
-      @dest << (s = str.to_s)
-      @dest << "\n" unless s[-1] == ?\n
-    end
-    @dest << "\n" if args.empty?
-    nil
-  end
-
-  def putc( ch )
-    stream_check!
-    @dest << ch.chr
-    nil
-  end
-
-  def printf( *args )
-    stream_check!
-    @dest << sprintf(*args)
-    nil
-  end
-
-  def write( str )
-    stream_check!
-    s = str.to_s
-    @dest << s
-    s.size
-  end
-
-  alias syswrite write
-
-  def <<( str )
-    stream_check!
-    @dest << str.to_s
-    self
-  end
-
-  private
-
-  def stream_check!
-    @closed and raise IOError, 'closed stream'
-  end
-
-end

actionmailer/lib/action_mailer/vendor/tmail-1.2.3/tmail/utils.rb

@@ -1,337 +0,0 @@
-#--
-# Copyright (c) 1998-2003 Minero Aoki <aamine@loveruby.net>
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-# Note: Originally licensed under LGPL v2+. Using MIT license for Rails
-# with permission of Minero Aoki.
-#++
-
-# = TMail - The EMail Swiss Army Knife for Ruby
-# 
-# The TMail library provides you with a very complete way to handle and manipulate EMails
-# from within your Ruby programs.
-# 
-# Used as the backbone for email handling by the Ruby on Rails and Nitro web frameworks as
-# well as a bunch of other Ruby apps including the Ruby-Talk mailing list to newsgroup email
-# gateway, it is a proven and reliable email handler that won't let you down.
-# 
-# Originally created by Minero Aoki, TMail has been recently picked up by Mikel Lindsaar and
-# is being actively maintained.  Numerous backlogged bug fixes have been applied as well as
-# Ruby 1.9 compatibility and a swath of documentation to boot.
-# 
-# TMail allows you to treat an email totally as an object and allow you to get on with your
-# own programming without having to worry about crafting the perfect email address validation
-# parser, or assembling an email from all it's component parts.
-# 
-# TMail handles the most complex part of the email - the header.  It generates and parses
-# headers and provides you with instant access to their innards through simple and logically
-# named accessor and setter methods.
-# 
-# TMail also provides a wrapper to Net/SMTP as well as Unix Mailbox handling methods to
-# directly read emails from your unix mailbox, parse them and use them.
-# 
-# Following is the comprehensive list of methods to access TMail::Mail objects.  You can also
-# check out TMail::Mail, TMail::Address and TMail::Headers for other lists.
-module TMail
-
-  # Provides an exception to throw on errors in Syntax within TMail's parsers
-  class SyntaxError < StandardError; end
-
-  # Provides a new email boundary to separate parts of the email.  This is a random
-  # string based off the current time, so should be fairly unique.
-  # 
-  # For Example:
-  # 
-  #  TMail.new_boundary
-  #  #=> "mimepart_47bf656968207_25a8fbb80114"
-  #  TMail.new_boundary
-  #  #=> "mimepart_47bf66051de4_25a8fbb80240"
-  def TMail.new_boundary
-    'mimepart_' + random_tag
-  end
-
-  # Provides a new email message ID.  You can use this to generate unique email message
-  # id's for your email so you can track them.
-  # 
-  # Optionally takes a fully qualified domain name (default to the current hostname 
-  # returned by Socket.gethostname) that will be appended to the message ID.
-  # 
-  # For Example:
-  # 
-  #  email.message_id = TMail.new_message_id
-  #  #=> "<47bf66845380e_25a8fbb80332@baci.local.tmail>"
-  #  email.to_s
-  #  #=> "Message-Id: <47bf668b633f1_25a8fbb80475@baci.local.tmail>\n\n"
-  #  email.message_id = TMail.new_message_id("lindsaar.net")
-  #  #=> "<47bf668b633f1_25a8fbb80475@lindsaar.net.tmail>"
-  #  email.to_s
-  #  #=> "Message-Id: <47bf668b633f1_25a8fbb80475@lindsaar.net.tmail>\n\n"
-  def TMail.new_message_id( fqdn = nil )
-    fqdn ||= ::Socket.gethostname
-    "<#{random_tag()}@#{fqdn}.tmail>"
-  end
-
-  #:stopdoc:
-  def TMail.random_tag #:nodoc:
-    @uniq += 1
-    t = Time.now
-    sprintf('%x%x_%x%x%d%x',
-            t.to_i, t.tv_usec,
-            $$, Thread.current.object_id, @uniq, rand(255))
-  end
-  private_class_method :random_tag
-
-  @uniq = 0
-
-  #:startdoc:
-  
-  # Text Utils provides a namespace to define TOKENs, ATOMs, PHRASEs and CONTROL characters that
-  # are OK per RFC 2822.
-  # 
-  # It also provides methods you can call to determine if a string is safe
-  module TextUtils
-
-    aspecial     = %Q|()<>[]:;.\\,"|
-    tspecial     = %Q|()<>[];:\\,"/?=|
-    lwsp         = %Q| \t\r\n|
-    control      = %Q|\x00-\x1f\x7f-\xff|
-
-    CONTROL_CHAR  = /[#{control}]/n
-    ATOM_UNSAFE   = /[#{Regexp.quote aspecial}#{control}#{lwsp}]/n
-    PHRASE_UNSAFE = /[#{Regexp.quote aspecial}#{control}]/n
-    TOKEN_UNSAFE  = /[#{Regexp.quote tspecial}#{control}#{lwsp}]/n
-    
-    # Returns true if the string supplied is free from characters not allowed as an ATOM
-    def atom_safe?( str )
-      not ATOM_UNSAFE === str
-    end
-
-    # If the string supplied has ATOM unsafe characters in it, will return the string quoted 
-    # in double quotes, otherwise returns the string unmodified
-    def quote_atom( str )
-      (ATOM_UNSAFE === str) ? dquote(str) : str
-    end
-
-    # If the string supplied has PHRASE unsafe characters in it, will return the string quoted 
-    # in double quotes, otherwise returns the string unmodified
-    def quote_phrase( str )
-      (PHRASE_UNSAFE === str) ? dquote(str) : str
-    end
-
-    # Returns true if the string supplied is free from characters not allowed as a TOKEN
-    def token_safe?( str )
-      not TOKEN_UNSAFE === str
-    end
-
-    # If the string supplied has TOKEN unsafe characters in it, will return the string quoted 
-    # in double quotes, otherwise returns the string unmodified
-    def quote_token( str )
-      (TOKEN_UNSAFE === str) ? dquote(str) : str
-    end
-
-    # Wraps supplied string in double quotes unless it is already wrapped
-    # Returns double quoted string
-    def dquote( str ) #:nodoc:
-      unless str =~ /^".*?"$/
-        '"' + str.gsub(/["\\]/n) {|s| '\\' + s } + '"'
-      else
-        str
-      end
-    end
-    private :dquote
-
-    # Unwraps supplied string from inside double quotes
-    # Returns unquoted string
-    def unquote( str )
-      str =~ /^"(.*?)"$/ ? $1 : str
-    end
-    
-    # Provides a method to join a domain name by it's parts and also makes it
-    # ATOM safe by quoting it as needed
-    def join_domain( arr )
-      arr.map {|i|
-          if /\A\[.*\]\z/ === i
-            i
-          else
-            quote_atom(i)
-          end
-      }.join('.')
-    end
-
-    #:stopdoc:
-    ZONESTR_TABLE = {
-      'jst' =>   9 * 60,
-      'eet' =>   2 * 60,
-      'bst' =>   1 * 60,
-      'met' =>   1 * 60,
-      'gmt' =>   0,
-      'utc' =>   0,
-      'ut'  =>   0,
-      'nst' => -(3 * 60 + 30),
-      'ast' =>  -4 * 60,
-      'edt' =>  -4 * 60,
-      'est' =>  -5 * 60,
-      'cdt' =>  -5 * 60,
-      'cst' =>  -6 * 60,
-      'mdt' =>  -6 * 60,
-      'mst' =>  -7 * 60,
-      'pdt' =>  -7 * 60,
-      'pst' =>  -8 * 60,
-      'a'   =>  -1 * 60,
-      'b'   =>  -2 * 60,
-      'c'   =>  -3 * 60,
-      'd'   =>  -4 * 60,
-      'e'   =>  -5 * 60,
-      'f'   =>  -6 * 60,
-      'g'   =>  -7 * 60,
-      'h'   =>  -8 * 60,
-      'i'   =>  -9 * 60,
-      # j not use
-      'k'   => -10 * 60,
-      'l'   => -11 * 60,
-      'm'   => -12 * 60,
-      'n'   =>   1 * 60,
-      'o'   =>   2 * 60,
-      'p'   =>   3 * 60,
-      'q'   =>   4 * 60,
-      'r'   =>   5 * 60,
-      's'   =>   6 * 60,
-      't'   =>   7 * 60,
-      'u'   =>   8 * 60,
-      'v'   =>   9 * 60,
-      'w'   =>  10 * 60,
-      'x'   =>  11 * 60,
-      'y'   =>  12 * 60,
-      'z'   =>   0 * 60
-    }
-    #:startdoc:
-
-    # Takes a time zone string from an EMail and converts it to Unix Time (seconds)
-    def timezone_string_to_unixtime( str )
-      if m = /([\+\-])(\d\d?)(\d\d)/.match(str)
-        sec = (m[2].to_i * 60 + m[3].to_i) * 60
-        m[1] == '-' ? -sec : sec
-      else
-        min = ZONESTR_TABLE[str.downcase] or
-                raise SyntaxError, "wrong timezone format '#{str}'"
-        min * 60
-      end
-    end
-
-    #:stopdoc:
-    WDAY = %w( Sun Mon Tue Wed Thu Fri Sat TMailBUG )
-    MONTH = %w( TMailBUG Jan Feb Mar Apr May Jun
-                         Jul Aug Sep Oct Nov Dec TMailBUG )
-
-    def time2str( tm )
-      # [ruby-list:7928]
-      gmt = Time.at(tm.to_i)
-      gmt.gmtime
-      offset = tm.to_i - Time.local(*gmt.to_a[0,6].reverse).to_i
-
-      # DO NOT USE strftime: setlocale() breaks it
-      sprintf '%s, %s %s %d %02d:%02d:%02d %+.2d%.2d',
-              WDAY[tm.wday], tm.mday, MONTH[tm.month],
-              tm.year, tm.hour, tm.min, tm.sec,
-              *(offset / 60).divmod(60)
-    end
-
-
-    MESSAGE_ID = /<[^\@>]+\@[^>\@]+>/
-    
-    def message_id?( str )
-      MESSAGE_ID === str
-    end
-
-
-    MIME_ENCODED = /=\?[^\s?=]+\?[QB]\?[^\s?=]+\?=/i
-
-    def mime_encoded?( str )
-      MIME_ENCODED === str
-    end
-  
-
-    def decode_params( hash )
-      new = Hash.new
-      encoded = nil
-      hash.each do |key, value|
-        if m = /\*(?:(\d+)\*)?\z/.match(key)
-          ((encoded ||= {})[m.pre_match] ||= [])[(m[1] || 0).to_i] = value
-        else
-          new[key] = to_kcode(value)
-        end
-      end
-      if encoded
-        encoded.each do |key, strings|
-          new[key] = decode_RFC2231(strings.join(''))
-        end
-      end
-
-      new
-    end
-
-    NKF_FLAGS = {
-      'EUC'  => '-e -m',
-      'SJIS' => '-s -m'
-    }
-
-    def to_kcode( str )
-      flag = NKF_FLAGS[TMail.KCODE] or return str
-      NKF.nkf(flag, str)
-    end
-
-    RFC2231_ENCODED = /\A(?:iso-2022-jp|euc-jp|shift_jis|us-ascii)?'[a-z]*'/in
-
-    def decode_RFC2231( str )
-      m = RFC2231_ENCODED.match(str) or return str
-      begin
-        to_kcode(m.post_match.gsub(/%[\da-f]{2}/in) {|s| s[1,2].hex.chr })
-      rescue
-        m.post_match.gsub(/%[\da-f]{2}/in, "")
-      end
-    end
-
-    def quote_boundary
-      # Make sure the Content-Type boundary= parameter is quoted if it contains illegal characters
-      # (to ensure any special characters in the boundary text are escaped from the parser
-      # (such as = in MS Outlook's boundary text))
-      if @body =~ /^(.*)boundary=(.*)$/m
-        preamble = $1
-        remainder = $2
-        if remainder =~ /;/
-          remainder =~ /^(.*?)(;.*)$/m
-          boundary_text = $1
-          post = $2.chomp
-        else
-          boundary_text = remainder.chomp
-        end
-        if boundary_text =~ /[\/\?\=]/
-          boundary_text = "\"#{boundary_text}\"" unless boundary_text =~ /^".*?"$/
-          @body = "#{preamble}boundary=#{boundary_text}#{post}"
-        end
-      end
-    end
-    #:startdoc:
-
-
-  end
-
-end

actionmailer/lib/action_mailer/vendor/tmail-1.2.3/tmail/version.rb

@@ -1,39 +0,0 @@
-#
-# version.rb
-#
-#--
-# Copyright (c) 1998-2003 Minero Aoki <aamine@loveruby.net>
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-#
-# Note: Originally licensed under LGPL v2+. Using MIT license for Rails
-# with permission of Minero Aoki.
-#++
-
-#:stopdoc:
-module TMail
-  module VERSION
-    MAJOR = 1
-    MINOR = 2
-    TINY  = 3
-
-    STRING = [MAJOR, MINOR, TINY].join('.')
-  end
-end

actionmailer/lib/action_mailer/vendor/tmail.rb

@@ -1,17 +0,0 @@
-# Prefer gems to the bundled libs.
-require 'rubygems'
-
-begin
-  gem 'tmail', '~> 1.2.3'
-rescue Gem::LoadError
-  $:.unshift "#{File.dirname(__FILE__)}/tmail-1.2.3"
-end
-
-module TMail
-end
-
-require 'tmail'
-
-silence_warnings do
-  TMail::Encoder.const_set("MAX_LINE_LEN", 200)
-end

actionmailer/lib/action_mailer/version.rb

@@ -1,9 +1,10 @@
 module ActionMailer
   module VERSION #:nodoc:
-    MAJOR = 2
-    MINOR = 3
-    TINY  = 2
+    MAJOR = 3
+    MINOR = 0
+    TINY  = 0
+    BUILD = "rc"
 
-    STRING = [MAJOR, MINOR, TINY].join('.')
+    STRING = [MAJOR, MINOR, TINY, BUILD].join('.')
   end
 end

actionmailer/lib/actionmailer.rb

@@ -1 +0,0 @@
-require 'action_mailer'

actionmailer/lib/rails/generators/mailer/USAGE

@@ -2,15 +2,14 @@ Description:
     Stubs out a new mailer and its views. Pass the mailer name, either
     CamelCased or under_scored, and an optional list of emails as arguments.
 
-    This generates a mailer class in app/models, view templates in
-    app/views/mailer_name, a unit test in test/unit, and fixtures in
-    test/fixtures.
+    This generates a mailer class in app/mailers and invokes your template
+    engine and test framework generators.
 
 Example:
-    `./script/generate mailer Notifications signup forgot_password invoice`
+    `rails generate mailer Notifications signup forgot_password invoice`
 
     creates a Notifications mailer class, views, test, and fixtures:
-        Mailer:     app/models/notifications.rb
+        Mailer:     app/mailers/notifications.rb
         Views:      app/views/notifications/signup.erb [...]
-        Test:       test/unit/test/unit/notifications_test.rb
+        Test:       test/functional/notifications_test.rb
         Fixtures:   test/fixtures/notifications/signup [...]

actionmailer/lib/rails/generators/mailer/mailer_generator.rb

@@ -0,0 +1,16 @@
+module Rails
+  module Generators
+    class MailerGenerator < NamedBase
+      source_root File.expand_path("../templates", __FILE__)
+
+      argument :actions, :type => :array, :default => [], :banner => "method method"
+      check_class_collision
+
+      def create_mailer_file
+        template "mailer.rb", File.join('app/mailers', class_path, "#{file_name}.rb")
+      end
+
+      hook_for :template_engine, :test_framework
+    end
+  end
+end

actionmailer/lib/rails/generators/mailer/templates/mailer.rb

@@ -0,0 +1,16 @@
+class <%= class_name %> < ActionMailer::Base
+  default :from => "from@example.com"
+<% for  action in actions -%>
+
+  # Subject can be set in your I18n file at config/locales/en.yml
+  # with the following lookup:
+  #
+  #   en.<%= file_name %>.<%= action %>.subject
+  #
+  def <%= action %>
+    @greeting = "Hi"
+
+    mail :to => "to@example.org"
+  end
+<% end  -%>
+end

actionmailer/test/abstract_unit.rb

@@ -1,12 +1,28 @@
-require 'rubygems'
+# Pathname has a warning, so require it first while silencing
+# warnings to shut it up.
+#
+# Also, in 1.9, Bundler creates warnings due to overriding
+# Rubygems methods
+begin
+  old, $VERBOSE = $VERBOSE, nil
+  require 'pathname'
+  require File.expand_path('../../../load_paths', __FILE__)
+ensure
+  $VERBOSE = old
+end
+
+
+require 'active_support/core_ext/kernel/reporting'
+silence_warnings do
+  # These external dependencies have warnings :/
+  require 'text/format'
+  require 'mail'
+end
+
+lib = File.expand_path("#{File.dirname(__FILE__)}/../lib")
+$:.unshift(lib) unless $:.include?('lib') || $:.include?(lib)
+
 require 'test/unit'
-
-gem 'mocha', '>= 0.9.5'
-require 'mocha'
-
-$:.unshift "#{File.dirname(__FILE__)}/../lib"
-$:.unshift "#{File.dirname(__FILE__)}/../../activesupport/lib"
-$:.unshift "#{File.dirname(__FILE__)}/../../actionpack/lib"
 require 'action_mailer'
 require 'action_mailer/test_case'
 
@@ -17,11 +33,8 @@ ActiveSupport::Deprecation.debug = true
 ActionView::Template.register_template_handler :haml, lambda { |template| "Look its HAML!".inspect }
 ActionView::Template.register_template_handler :bak, lambda { |template| "Lame backup".inspect }
 
-$:.unshift "#{File.dirname(__FILE__)}/fixtures/helpers"
-
-ActionView::Base.cache_template_loading = true
-FIXTURE_LOAD_PATH = File.join(File.dirname(__FILE__), 'fixtures')
-ActionMailer::Base.template_root = FIXTURE_LOAD_PATH
+FIXTURE_LOAD_PATH = File.expand_path('fixtures', File.dirname(__FILE__))
+ActionMailer::Base.view_paths = FIXTURE_LOAD_PATH
 
 class MockSMTP
   def self.deliveries
@@ -47,19 +60,11 @@ class Net::SMTP
   end
 end
 
-def uses_gem(gem_name, test_name, version = '> 0')
-  gem gem_name.to_s, version
-  require gem_name.to_s
-  yield
-rescue LoadError
-  $stderr.puts "Skipping #{test_name} tests. `gem install #{gem_name}` and try again."
-end
-
-def set_delivery_method(delivery_method)
+def set_delivery_method(method)
   @old_delivery_method = ActionMailer::Base.delivery_method
-  ActionMailer::Base.delivery_method = delivery_method
+  ActionMailer::Base.delivery_method = method
 end
 
 def restore_delivery_method
   ActionMailer::Base.delivery_method = @old_delivery_method
-end
+end

actionmailer/test/asset_host_test.rb

@@ -1,54 +0,0 @@
-require 'abstract_unit'
-
-class AssetHostMailer < ActionMailer::Base
-  def email_with_asset(recipient)
-    recipients recipient
-    subject    "testing email containing asset path while asset_host is set"
-    from       "tester@example.com"
-  end
-end
-
-class AssetHostTest < Test::Unit::TestCase
-  def setup
-    set_delivery_method :test
-    ActionMailer::Base.perform_deliveries = true
-    ActionMailer::Base.deliveries = []
-
-    @recipient = 'test@localhost'
-  end
-
-  def teardown
-    restore_delivery_method
-  end
-
-  def test_asset_host_as_string
-    ActionController::Base.asset_host = "http://www.example.com"
-    mail = AssetHostMailer.deliver_email_with_asset(@recipient)
-    assert_equal "<img alt=\"Somelogo\" src=\"http://www.example.com/images/somelogo.png\" />", mail.body.strip
-  end
-
-  def test_asset_host_as_one_arguement_proc
-    ActionController::Base.asset_host = Proc.new { |source|
-      if source.starts_with?('/images')
-        "http://images.example.com"
-      else
-        "http://assets.example.com"
-      end
-    }
-    mail = AssetHostMailer.deliver_email_with_asset(@recipient)
-    assert_equal "<img alt=\"Somelogo\" src=\"http://images.example.com/images/somelogo.png\" />", mail.body.strip
-  end
-
-  def test_asset_host_as_two_arguement_proc
-    ActionController::Base.asset_host = Proc.new {|source,request|
-      if request && request.ssl?
-        "https://www.example.com"
-      else
-        "http://www.example.com"
-      end
-    }
-    mail = nil
-    assert_nothing_raised { mail = AssetHostMailer.deliver_email_with_asset(@recipient) }
-    assert_equal "<img alt=\"Somelogo\" src=\"http://www.example.com/images/somelogo.png\" />", mail.body.strip
-  end
-end

actionmailer/test/base_test.rb

@@ -0,0 +1,534 @@
+# encoding: utf-8
+require 'abstract_unit'
+require 'active_support/time'
+
+require 'mailers/base_mailer'
+require 'mailers/proc_mailer'
+require 'mailers/asset_mailer'
+
+class BaseTest < ActiveSupport::TestCase
+  # TODO Add some tests for implicity layout render and url helpers
+  # so we can get rid of old base tests altogether with old base.
+
+  def teardown
+    ActionMailer::Base.asset_host = nil
+    ActionMailer::Base.assets_dir = nil
+  end
+
+  test "method call to mail does not raise error" do
+    assert_nothing_raised { BaseMailer.welcome }
+  end
+
+  # Basic mail usage without block
+  test "mail() should set the headers of the mail message" do
+    email = BaseMailer.welcome
+    assert_equal(['system@test.lindsaar.net'],    email.to)
+    assert_equal(['jose@test.plataformatec.com'], email.from)
+    assert_equal('The first email on new API!',   email.subject)
+  end
+
+  test "mail() with from overwrites the class level default" do
+    email = BaseMailer.welcome(:from => 'someone@example.com',
+                               :to   => 'another@example.org')
+    assert_equal(['someone@example.com'], email.from)
+    assert_equal(['another@example.org'], email.to)
+  end
+
+  test "mail() with bcc, cc, content_type, charset, mime_version, reply_to and date" do
+    @time = Time.now.beginning_of_day.to_datetime
+    email = BaseMailer.welcome(:bcc => 'bcc@test.lindsaar.net',
+                               :cc  => 'cc@test.lindsaar.net',
+                               :content_type => 'multipart/mixed',
+                               :charset => 'iso-8559-1',
+                               :mime_version => '2.0',
+                               :reply_to => 'reply-to@test.lindsaar.net',
+                               :date => @time)
+    assert_equal(['bcc@test.lindsaar.net'],             email.bcc)
+    assert_equal(['cc@test.lindsaar.net'],              email.cc)
+    assert_equal('multipart/mixed; charset=iso-8559-1', email.content_type)
+    assert_equal('iso-8559-1',                          email.charset)
+    assert_equal('2.0',                                 email.mime_version)
+    assert_equal(['reply-to@test.lindsaar.net'],        email.reply_to)
+    assert_equal(@time,                                 email.date)
+  end
+
+  test "mail() renders the template using the method being processed" do
+    email = BaseMailer.welcome
+    assert_equal("Welcome", email.body.encoded)
+  end
+
+  test "can pass in :body to the mail method hash" do
+    email = BaseMailer.welcome(:body => "Hello there")
+    assert_equal("text/plain", email.mime_type)
+    assert_equal("Hello there", email.body.encoded)
+  end
+
+  test "should set template content type if mail has only one part" do
+    mail = BaseMailer.html_only
+    assert_equal('text/html', mail.mime_type)
+    mail = BaseMailer.plain_text_only
+    assert_equal('text/plain', mail.mime_type)
+  end
+
+  # Custom headers
+  test "custom headers" do
+    email = BaseMailer.welcome
+    assert_equal("Not SPAM", email['X-SPAM'].decoded)
+  end
+
+  test "can pass random headers in as a hash to mail" do
+    hash = {'X-Special-Domain-Specific-Header' => "SecretValue",
+            'In-Reply-To' => '1234@mikel.me.com' }
+    mail = BaseMailer.welcome(hash)
+    assert_equal('SecretValue', mail['X-Special-Domain-Specific-Header'].decoded)
+    assert_equal('1234@mikel.me.com', mail['In-Reply-To'].decoded)
+  end
+
+  test "can pass random headers in as a hash to headers" do
+    hash = {'X-Special-Domain-Specific-Header' => "SecretValue",
+            'In-Reply-To' => '1234@mikel.me.com' }
+    mail = BaseMailer.welcome_with_headers(hash)
+    assert_equal('SecretValue', mail['X-Special-Domain-Specific-Header'].decoded)
+    assert_equal('1234@mikel.me.com', mail['In-Reply-To'].decoded)
+  end
+
+  # Attachments
+  test "attachment with content" do
+    email = BaseMailer.attachment_with_content
+    assert_equal(1, email.attachments.length)
+    assert_equal('invoice.pdf', email.attachments[0].filename)
+    assert_equal('This is test File content', email.attachments['invoice.pdf'].decoded)
+  end
+
+  test "attachment gets content type from filename" do
+    email = BaseMailer.attachment_with_content
+    assert_equal('invoice.pdf', email.attachments[0].filename)
+  end
+
+  test "attachment with hash" do
+    email = BaseMailer.attachment_with_hash
+    assert_equal(1, email.attachments.length)
+    assert_equal('invoice.jpg', email.attachments[0].filename)
+    expected = "\312\213\254\232)b"
+    expected.force_encoding(Encoding::BINARY) if '1.9'.respond_to?(:force_encoding)
+    assert_equal expected, email.attachments['invoice.jpg'].decoded
+  end
+
+  test "attachment with hash using default mail encoding" do
+    email = BaseMailer.attachment_with_hash_default_encoding
+    assert_equal(1, email.attachments.length)
+    assert_equal('invoice.jpg', email.attachments[0].filename)
+    expected = "\312\213\254\232)b"
+    expected.force_encoding(Encoding::BINARY) if '1.9'.respond_to?(:force_encoding)
+    assert_equal expected, email.attachments['invoice.jpg'].decoded
+  end
+
+  test "sets mime type to multipart/mixed when attachment is included" do
+    email = BaseMailer.attachment_with_content
+    assert_equal(1, email.attachments.length)
+    assert_equal("multipart/mixed", email.mime_type)
+  end
+
+  test "adds the rendered template as part" do
+    email = BaseMailer.attachment_with_content
+    assert_equal(2, email.parts.length)
+    assert_equal("multipart/mixed", email.mime_type)
+    assert_equal("text/html", email.parts[0].mime_type)
+    assert_equal("Attachment with content", email.parts[0].body.encoded)
+    assert_equal("application/pdf", email.parts[1].mime_type)
+    assert_equal("VGhpcyBpcyB0ZXN0IEZpbGUgY29udGVudA==\r\n", email.parts[1].body.encoded)
+  end
+
+  test "adds the given :body as part" do
+    email = BaseMailer.attachment_with_content(:body => "I'm the eggman")
+    assert_equal(2, email.parts.length)
+    assert_equal("multipart/mixed", email.mime_type)
+    assert_equal("text/plain", email.parts[0].mime_type)
+    assert_equal("I'm the eggman", email.parts[0].body.encoded)
+    assert_equal("application/pdf", email.parts[1].mime_type)
+    assert_equal("VGhpcyBpcyB0ZXN0IEZpbGUgY29udGVudA==\r\n", email.parts[1].body.encoded)
+  end
+  
+  test "can embed an inline attachment" do
+    email = BaseMailer.inline_attachment
+    # Need to call #encoded to force the JIT sort on parts
+    email.encoded
+    assert_equal(2, email.parts.length)
+    assert_equal("multipart/related", email.mime_type)
+    assert_equal("multipart/alternative", email.parts[0].mime_type)
+      assert_equal("text/plain", email.parts[0].parts[0].mime_type)
+      assert_equal("text/html",  email.parts[0].parts[1].mime_type)
+    assert_equal("logo.png", email.parts[1].filename)
+  end
+
+  # Defaults values
+  test "uses default charset from class" do
+    with_default BaseMailer, :charset => "US-ASCII" do
+      email = BaseMailer.welcome
+      assert_equal("US-ASCII", email.charset)
+
+      email = BaseMailer.welcome(:charset => "iso-8559-1")
+      assert_equal("iso-8559-1", email.charset)
+    end
+  end
+
+  test "uses default content type from class" do
+    with_default BaseMailer, :content_type => "text/html" do
+      email = BaseMailer.welcome
+      assert_equal("text/html", email.mime_type)
+
+      email = BaseMailer.welcome(:content_type => "text/plain")
+      assert_equal("text/plain", email.mime_type)
+    end
+  end
+
+  test "uses default mime version from class" do
+    with_default BaseMailer, :mime_version => "2.0" do
+      email = BaseMailer.welcome
+      assert_equal("2.0", email.mime_version)
+
+      email = BaseMailer.welcome(:mime_version => "1.0")
+      assert_equal("1.0", email.mime_version)
+    end
+  end
+
+  test "uses random default headers from class" do
+    with_default BaseMailer, "X-Custom" => "Custom" do
+      email = BaseMailer.welcome
+      assert_equal("Custom", email["X-Custom"].decoded)
+    end
+  end
+
+  test "subject gets default from I18n" do
+    BaseMailer.default :subject => nil
+    email = BaseMailer.welcome(:subject => nil)
+    assert_equal "Welcome", email.subject
+
+    I18n.backend.store_translations('en', :base_mailer => {:welcome => {:subject => "New Subject!"}})
+    email = BaseMailer.welcome(:subject => nil)
+    assert_equal "New Subject!", email.subject
+  end
+
+  # Implicit multipart
+  test "implicit multipart" do
+    email = BaseMailer.implicit_multipart
+    assert_equal(2, email.parts.size)
+    assert_equal("multipart/alternative", email.mime_type)
+    assert_equal("text/plain", email.parts[0].mime_type)
+    assert_equal("TEXT Implicit Multipart", email.parts[0].body.encoded)
+    assert_equal("text/html", email.parts[1].mime_type)
+    assert_equal("HTML Implicit Multipart", email.parts[1].body.encoded)
+  end
+
+  test "implicit multipart with sort order" do
+    order = ["text/html", "text/plain"]
+    with_default BaseMailer, :parts_order => order do
+      email = BaseMailer.implicit_multipart
+      assert_equal("text/html",  email.parts[0].mime_type)
+      assert_equal("text/plain", email.parts[1].mime_type)
+
+      email = BaseMailer.implicit_multipart(:parts_order => order.reverse)
+      assert_equal("text/plain", email.parts[0].mime_type)
+      assert_equal("text/html",  email.parts[1].mime_type)
+    end
+  end
+
+  test "implicit multipart with attachments creates nested parts" do
+    email = BaseMailer.implicit_multipart(:attachments => true)
+    assert_equal("application/pdf", email.parts[0].mime_type)
+    assert_equal("multipart/alternative", email.parts[1].mime_type)
+    assert_equal("text/plain", email.parts[1].parts[0].mime_type)
+    assert_equal("TEXT Implicit Multipart", email.parts[1].parts[0].body.encoded)
+    assert_equal("text/html", email.parts[1].parts[1].mime_type)
+    assert_equal("HTML Implicit Multipart", email.parts[1].parts[1].body.encoded)
+  end
+
+  test "implicit multipart with attachments and sort order" do
+    order = ["text/html", "text/plain"]
+    with_default BaseMailer, :parts_order => order do
+      email = BaseMailer.implicit_multipart(:attachments => true)
+      assert_equal("application/pdf", email.parts[0].mime_type)
+      assert_equal("multipart/alternative", email.parts[1].mime_type)
+      assert_equal("text/plain", email.parts[1].parts[1].mime_type)
+      assert_equal("text/html", email.parts[1].parts[0].mime_type)
+    end
+  end
+
+  test "implicit multipart with default locale" do
+    email = BaseMailer.implicit_with_locale
+    assert_equal(2, email.parts.size)
+    assert_equal("multipart/alternative", email.mime_type)
+    assert_equal("text/plain", email.parts[0].mime_type)
+    assert_equal("Implicit with locale TEXT", email.parts[0].body.encoded)
+    assert_equal("text/html", email.parts[1].mime_type)
+    assert_equal("Implicit with locale EN HTML", email.parts[1].body.encoded)
+  end
+
+  test "implicit multipart with other locale" do
+    swap I18n, :locale => :pl do
+      email = BaseMailer.implicit_with_locale
+      assert_equal(2, email.parts.size)
+      assert_equal("multipart/alternative", email.mime_type)
+      assert_equal("text/plain", email.parts[0].mime_type)
+      assert_equal("Implicit with locale PL TEXT", email.parts[0].body.encoded)
+      assert_equal("text/html", email.parts[1].mime_type)
+      assert_equal("Implicit with locale HTML", email.parts[1].body.encoded)
+    end
+  end
+
+  test "implicit multipart with several view paths uses the first one with template" do
+    old = BaseMailer.view_paths
+    begin
+      BaseMailer.view_paths = [File.join(FIXTURE_LOAD_PATH, "another.path")] + old.dup
+      email = BaseMailer.welcome
+      assert_equal("Welcome from another path", email.body.encoded)
+    ensure
+      BaseMailer.view_paths = old
+    end
+  end
+
+  test "implicit multipart with inexistent templates uses the next view path" do
+    old = BaseMailer.view_paths
+    begin
+      BaseMailer.view_paths = [File.join(FIXTURE_LOAD_PATH, "unknown")] + old.dup
+      email = BaseMailer.welcome
+      assert_equal("Welcome", email.body.encoded)
+    ensure
+      BaseMailer.view_paths = old
+    end
+  end
+
+  # Explicit multipart
+  test "explicit multipart" do
+    email = BaseMailer.explicit_multipart
+    assert_equal(2, email.parts.size)
+    assert_equal("multipart/alternative", email.mime_type)
+    assert_equal("text/plain", email.parts[0].mime_type)
+    assert_equal("TEXT Explicit Multipart", email.parts[0].body.encoded)
+    assert_equal("text/html", email.parts[1].mime_type)
+    assert_equal("HTML Explicit Multipart", email.parts[1].body.encoded)
+  end
+
+  test "explicit multipart have a boundary" do
+    mail = BaseMailer.explicit_multipart
+    assert_not_nil(mail.content_type_parameters[:boundary])
+  end
+
+  test "explicit multipart does not sort order" do
+    order = ["text/html", "text/plain"]
+    with_default BaseMailer, :parts_order => order do
+      email = BaseMailer.explicit_multipart
+      assert_equal("text/plain", email.parts[0].mime_type)
+      assert_equal("text/html",  email.parts[1].mime_type)
+
+      email = BaseMailer.explicit_multipart(:parts_order => order.reverse)
+      assert_equal("text/plain", email.parts[0].mime_type)
+      assert_equal("text/html",  email.parts[1].mime_type)
+    end
+  end
+
+  test "explicit multipart with attachments creates nested parts" do
+    email = BaseMailer.explicit_multipart(:attachments => true)
+    assert_equal("application/pdf", email.parts[0].mime_type)
+    assert_equal("multipart/alternative", email.parts[1].mime_type)
+    assert_equal("text/plain", email.parts[1].parts[0].mime_type)
+    assert_equal("TEXT Explicit Multipart", email.parts[1].parts[0].body.encoded)
+    assert_equal("text/html", email.parts[1].parts[1].mime_type)
+    assert_equal("HTML Explicit Multipart", email.parts[1].parts[1].body.encoded)
+  end
+
+  test "explicit multipart with templates" do
+    email = BaseMailer.explicit_multipart_templates
+    assert_equal(2, email.parts.size)
+    assert_equal("multipart/alternative", email.mime_type)
+    assert_equal("text/html", email.parts[0].mime_type)
+    assert_equal("HTML Explicit Multipart Templates", email.parts[0].body.encoded)
+    assert_equal("text/plain", email.parts[1].mime_type)
+    assert_equal("TEXT Explicit Multipart Templates", email.parts[1].body.encoded)
+  end
+
+  test "explicit multipart with format.any" do
+    email = BaseMailer.explicit_multipart_with_any
+    assert_equal(2, email.parts.size)
+    assert_equal("multipart/alternative", email.mime_type)
+    assert_equal("text/plain", email.parts[0].mime_type)
+    assert_equal("Format with any!", email.parts[0].body.encoded)
+    assert_equal("text/html", email.parts[1].mime_type)
+    assert_equal("Format with any!", email.parts[1].body.encoded)
+  end
+
+  test "explicit multipart with format(Hash)" do
+    email = BaseMailer.explicit_multipart_with_options(true)
+    email.ready_to_send!
+    assert_equal(2, email.parts.size)
+    assert_equal("multipart/alternative", email.mime_type)
+    assert_equal("text/plain", email.parts[0].mime_type)
+    assert_equal("base64", email.parts[0].content_transfer_encoding)
+    assert_equal("text/html", email.parts[1].mime_type)
+    assert_equal("7bit", email.parts[1].content_transfer_encoding)
+  end
+
+  test "explicit multipart with one part is rendered as body and options are merged" do
+    email = BaseMailer.explicit_multipart_with_options
+    assert_equal(0, email.parts.size)
+    assert_equal("text/plain", email.mime_type)
+    assert_equal("base64", email.content_transfer_encoding)
+  end
+
+  test "explicit multipart with one template has the expected format" do
+    email = BaseMailer.explicit_multipart_with_one_template
+    assert_equal(2, email.parts.size)
+    assert_equal("multipart/alternative", email.mime_type)
+    assert_equal("text/html", email.parts[0].mime_type)
+    assert_equal("[:html]", email.parts[0].body.encoded)
+    assert_equal("text/plain", email.parts[1].mime_type)
+    assert_equal("[:text]", email.parts[1].body.encoded)
+  end
+
+  # Class level API with method missing
+  test "should respond to action methods" do
+    assert_respond_to BaseMailer, :welcome
+    assert_respond_to BaseMailer, :implicit_multipart
+    assert !BaseMailer.respond_to?(:mail)
+    assert !BaseMailer.respond_to?(:headers)
+  end
+
+  test "calling just the action should return the generated mail object" do
+    BaseMailer.deliveries.clear
+    email = BaseMailer.welcome
+    assert_equal(0, BaseMailer.deliveries.length)
+    assert_equal('The first email on new API!', email.subject)
+  end
+
+  test "calling deliver on the action should deliver the mail object" do
+    BaseMailer.deliveries.clear
+    BaseMailer.expects(:deliver_mail).once
+    mail = BaseMailer.welcome.deliver
+    assert_instance_of Mail::Message, mail
+  end
+
+  test "calling deliver on the action should increment the deliveries collection if using the test mailer" do
+    BaseMailer.delivery_method = :test
+    BaseMailer.deliveries.clear
+    BaseMailer.welcome.deliver
+    assert_equal(1, BaseMailer.deliveries.length)
+  end
+  
+  test "calling deliver, ActionMailer should yield back to mail to let it call :do_delivery on itself" do
+    mail = Mail::Message.new
+    mail.expects(:do_delivery).once
+    BaseMailer.expects(:welcome).returns(mail)
+    BaseMailer.welcome.deliver
+  end
+
+  # Rendering
+  test "you can specify a different template for implicit render" do
+    mail = BaseMailer.implicit_different_template('implicit_multipart').deliver
+    assert_equal("HTML Implicit Multipart", mail.html_part.body.decoded)
+    assert_equal("TEXT Implicit Multipart", mail.text_part.body.decoded)
+  end
+
+  test "you can specify a different template for explicit render" do
+    mail = BaseMailer.explicit_different_template('explicit_multipart_templates').deliver
+    assert_equal("HTML Explicit Multipart Templates", mail.html_part.body.decoded)
+    assert_equal("TEXT Explicit Multipart Templates", mail.text_part.body.decoded)
+  end
+
+  test "you can specify a different layout" do
+    mail = BaseMailer.different_layout('different_layout').deliver
+    assert_equal("HTML -- HTML", mail.html_part.body.decoded)
+    assert_equal("PLAIN -- PLAIN", mail.text_part.body.decoded)
+  end
+
+  test "you can specify the template path for implicit lookup" do
+    mail = BaseMailer.welcome_from_another_path('another.path/base_mailer').deliver
+    assert_equal("Welcome from another path", mail.body.encoded)
+
+    mail = BaseMailer.welcome_from_another_path(['unknown/invalid', 'another.path/base_mailer']).deliver
+    assert_equal("Welcome from another path", mail.body.encoded)
+  end
+  
+  test "assets tags should use ActionMailer's asset_host settings" do
+    ActionMailer::Base.config.asset_host = "http://global.com"
+    ActionMailer::Base.config.assets_dir = "global/"
+
+    mail = AssetMailer.welcome
+
+    assert_equal(%{<img alt="Dummy" src="http://global.com/images/dummy.png" />}, mail.body.to_s.strip)
+  end
+  
+  test "assets tags should use a Mailer's asset_host settings when available" do
+    ActionMailer::Base.config.asset_host = "global.com"
+    ActionMailer::Base.config.assets_dir = "global/"
+
+    AssetMailer.asset_host = "http://local.com"
+
+    mail = AssetMailer.welcome
+
+    assert_equal(%{<img alt="Dummy" src="http://local.com/images/dummy.png" />}, mail.body.to_s.strip)
+  end
+
+  # Before and After hooks
+  
+  class MyObserver
+    def self.delivered_email(mail)
+    end
+  end
+  
+  test "you can register an observer to the mail object that gets informed on email delivery" do
+    ActionMailer::Base.register_observer(MyObserver)
+    mail = BaseMailer.welcome
+    MyObserver.expects(:delivered_email).with(mail)
+    mail.deliver
+  end
+
+  class MyInterceptor
+    def self.delivering_email(mail)
+    end
+  end
+
+  test "you can register an interceptor to the mail object that gets passed the mail object before delivery" do
+    ActionMailer::Base.register_interceptor(MyInterceptor)
+    mail = BaseMailer.welcome
+    MyInterceptor.expects(:delivering_email).with(mail)
+    mail.deliver
+  end
+  
+  test "being able to put proc's into the defaults hash and they get evaluated on mail sending" do
+    mail1 = ProcMailer.welcome
+    yesterday = 1.day.ago
+    Time.stubs(:now).returns(yesterday)
+    mail2 = ProcMailer.welcome
+    assert(mail1['X-Proc-Method'].to_s.to_i > mail2['X-Proc-Method'].to_s.to_i)
+  end
+  
+  test "we can call other defined methods on the class as needed" do
+    mail = ProcMailer.welcome
+    assert_equal("Thanks for signing up this afternoon", mail.subject)
+  end
+
+  protected
+
+    # Execute the block setting the given values and restoring old values after
+    # the block is executed.
+    def swap(klass, new_values)
+      old_values = {}
+      new_values.each do |key, value|
+        old_values[key] = klass.send key
+        klass.send :"#{key}=", value
+      end
+      yield
+    ensure
+      old_values.each do |key, value|
+        klass.send :"#{key}=", value
+      end
+    end
+
+    def with_default(klass, new_values)
+      old = klass.default_params
+      klass.default(new_values)
+      yield
+    ensure
+      klass.default_params = old
+    end
+end

actionmailer/test/delivery_method_test.rb

@@ -1,51 +0,0 @@
-require 'abstract_unit'
-
-class DefaultDeliveryMethodMailer < ActionMailer::Base
-end
-
-class NonDefaultDeliveryMethodMailer < ActionMailer::Base
-  self.delivery_method = :sendmail
-end
-
-class ActionMailerBase_delivery_method_Test < Test::Unit::TestCase
-  def setup
-    set_delivery_method :smtp
-  end
-  
-  def teardown
-    restore_delivery_method
-  end
-
-  def test_should_be_the_default_smtp
-    assert_equal :smtp, ActionMailer::Base.delivery_method
-  end
-end
-
-class DefaultDeliveryMethodMailer_delivery_method_Test < Test::Unit::TestCase
-  def setup
-    set_delivery_method :smtp
-  end
-  
-  def teardown
-    restore_delivery_method
-  end
-  
-  def test_should_be_the_default_smtp
-    assert_equal :smtp, DefaultDeliveryMethodMailer.delivery_method
-  end
-end
-
-class NonDefaultDeliveryMethodMailer_delivery_method_Test < Test::Unit::TestCase
-  def setup
-    set_delivery_method :smtp
-  end
-  
-  def teardown
-    restore_delivery_method
-  end
-
-  def test_should_be_the_set_delivery_method
-    assert_equal :sendmail, NonDefaultDeliveryMethodMailer.delivery_method
-  end
-end
-

actionmailer/test/delivery_methods_test.rb

@@ -0,0 +1,172 @@
+require 'abstract_unit'
+require 'mail'
+
+class MyCustomDelivery
+end
+
+class BogusDelivery
+  def initialize(*)
+  end
+
+  def deliver!(mail)
+    raise "failed"
+  end
+end
+
+class DefaultsDeliveryMethodsTest < ActiveSupport::TestCase
+  test "default smtp settings" do
+    settings = { :address              => "localhost",
+                 :port                 => 25,
+                 :domain               => 'localhost.localdomain',
+                 :user_name            => nil,
+                 :password             => nil,
+                 :authentication       => nil,
+                 :enable_starttls_auto => true }
+    assert_equal settings, ActionMailer::Base.smtp_settings
+  end
+
+  test "default file delivery settings" do
+    settings = {:location => "#{Dir.tmpdir}/mails"}
+    assert_equal settings, ActionMailer::Base.file_settings
+  end
+
+  test "default sendmail settings" do
+    settings = {:location       => '/usr/sbin/sendmail',
+                :arguments      => '-i -t'}
+    assert_equal settings, ActionMailer::Base.sendmail_settings
+  end
+end
+
+class CustomDeliveryMethodsTest < ActiveSupport::TestCase
+  def setup
+    @old_delivery_method = ActionMailer::Base.delivery_method
+    ActionMailer::Base.add_delivery_method :custom, MyCustomDelivery
+  end
+
+  def teardown
+    ActionMailer::Base.delivery_method = @old_delivery_method
+    new = ActionMailer::Base.delivery_methods.dup
+    new.delete(:custom)
+    ActionMailer::Base.delivery_methods = new
+  end
+
+  test "allow to add custom delivery method" do
+    ActionMailer::Base.delivery_method = :custom
+    assert_equal :custom, ActionMailer::Base.delivery_method
+  end
+
+  test "allow to customize custom settings" do
+    ActionMailer::Base.custom_settings = { :foo => :bar }
+    assert_equal Hash[:foo => :bar], ActionMailer::Base.custom_settings
+  end
+
+  test "respond to custom settings" do
+    assert_respond_to ActionMailer::Base, :custom_settings
+    assert_respond_to ActionMailer::Base, :custom_settings=
+  end
+
+  test "does not respond to unknown settings" do
+    assert_raise NoMethodError do
+      ActionMailer::Base.another_settings
+    end
+  end
+end
+
+class MailDeliveryTest < ActiveSupport::TestCase
+  class DeliveryMailer < ActionMailer::Base
+    DEFAULT_HEADERS = {
+      :to => 'mikel@test.lindsaar.net',
+      :from => 'jose@test.plataformatec.com'
+    }
+
+    def welcome(hash={})
+      mail(DEFAULT_HEADERS.merge(hash))
+    end
+  end
+
+  def setup
+    ActionMailer::Base.delivery_method = :smtp
+  end
+
+  def teardown
+    DeliveryMailer.delivery_method = :smtp
+    DeliveryMailer.perform_deliveries = true
+    DeliveryMailer.raise_delivery_errors = true
+  end
+
+  test "ActionMailer should be told when Mail gets delivered" do
+    DeliveryMailer.deliveries.clear
+    DeliveryMailer.expects(:deliver_mail).once
+    DeliveryMailer.welcome.deliver
+  end
+
+  test "delivery method can be customized per instance" do
+    email = DeliveryMailer.welcome.deliver
+    assert_instance_of Mail::SMTP, email.delivery_method
+    email = DeliveryMailer.welcome(:delivery_method => :test).deliver
+    assert_instance_of Mail::TestMailer, email.delivery_method
+  end
+
+  test "delivery method can be customized in subclasses not changing the parent" do
+    DeliveryMailer.delivery_method = :test
+    assert_equal :smtp, ActionMailer::Base.delivery_method
+    $BREAK = true
+    email = DeliveryMailer.welcome.deliver
+    assert_instance_of Mail::TestMailer, email.delivery_method
+  end
+
+  test "non registered delivery methods raises errors" do
+    DeliveryMailer.delivery_method = :unknown
+    assert_raise RuntimeError do
+      DeliveryMailer.welcome.deliver
+    end
+  end
+
+  test "does not perform deliveries if requested" do
+    DeliveryMailer.perform_deliveries = false
+    DeliveryMailer.deliveries.clear
+    Mail::Message.any_instance.expects(:deliver!).never
+    DeliveryMailer.welcome.deliver
+  end
+  
+  test "does not append the deliveries collection if told not to perform the delivery" do
+    DeliveryMailer.perform_deliveries = false
+    DeliveryMailer.deliveries.clear
+    DeliveryMailer.welcome.deliver
+    assert_equal(0, DeliveryMailer.deliveries.length)
+  end
+
+  test "raise errors on bogus deliveries" do
+    DeliveryMailer.delivery_method = BogusDelivery
+    DeliveryMailer.deliveries.clear
+    assert_raise RuntimeError do
+      DeliveryMailer.welcome.deliver
+    end
+  end
+
+  test "does not increment the deliveries collection on error" do
+    DeliveryMailer.delivery_method = BogusDelivery
+    DeliveryMailer.deliveries.clear
+    assert_raise RuntimeError do
+      DeliveryMailer.welcome.deliver
+    end
+    assert_equal(0, DeliveryMailer.deliveries.length)
+  end
+
+  test "does not raise errors on bogus deliveries if set" do
+    DeliveryMailer.delivery_method = BogusDelivery
+    DeliveryMailer.raise_delivery_errors = false
+    assert_nothing_raised do
+      DeliveryMailer.welcome.deliver
+    end
+  end
+  
+  test "does not increment the deliveries collection on bogus deliveries" do
+    DeliveryMailer.delivery_method = BogusDelivery
+    DeliveryMailer.raise_delivery_errors = false
+    DeliveryMailer.deliveries.clear
+    DeliveryMailer.welcome.deliver
+    assert_equal(0, DeliveryMailer.deliveries.length)
+  end
+  
+end

actionmailer/test/fixtures/another.path/base_mailer/welcome.erb

@@ -0,0 +1 @@
+Welcome from another path

actionmailer/test/fixtures/asset_mailer/welcome.html.erb

@@ -0,0 +1 @@
+<%= image_tag "dummy.png" %>

actionmailer/test/fixtures/base_mailer/attachment_with_content.erb

@@ -0,0 +1 @@
+Attachment with content

actionmailer/test/fixtures/base_mailer/different_layout.html.erb

@@ -0,0 +1 @@
+HTML

actionmailer/test/fixtures/base_mailer/different_layout.text.erb

@@ -0,0 +1 @@
+PLAIN

actionmailer/test/fixtures/base_mailer/email_custom_layout.text.html.erb

@@ -0,0 +1 @@
+body_text

actionmailer/test/fixtures/base_mailer/explicit_multipart_templates.html.erb

@@ -0,0 +1 @@
+HTML Explicit Multipart Templates

actionmailer/test/fixtures/base_mailer/explicit_multipart_templates.text.erb

@@ -0,0 +1 @@
+TEXT Explicit Multipart Templates

actionmailer/test/fixtures/base_mailer/explicit_multipart_with_one_template.erb

@@ -0,0 +1 @@
+<%= self.formats.inspect %>

actionmailer/test/fixtures/base_mailer/html_only.html.erb

@@ -0,0 +1 @@
+<h1>Testing</h1>

actionmailer/test/fixtures/base_mailer/implicit_multipart.html.erb

@@ -0,0 +1 @@
+HTML Implicit Multipart

actionmailer/test/fixtures/base_mailer/implicit_multipart.text.erb

@@ -0,0 +1 @@
+TEXT Implicit Multipart

actionmailer/test/fixtures/base_mailer/implicit_with_locale.en.html.erb

@@ -0,0 +1 @@
+Implicit with locale EN HTML

actionmailer/test/fixtures/base_mailer/implicit_with_locale.html.erb

@@ -0,0 +1 @@
+Implicit with locale HTML

actionmailer/test/fixtures/base_mailer/implicit_with_locale.pl.text.erb

@@ -0,0 +1 @@
+Implicit with locale PL TEXT

actionmailer/test/fixtures/base_mailer/implicit_with_locale.text.erb

@@ -0,0 +1 @@
+Implicit with locale TEXT

actionmailer/test/fixtures/base_mailer/inline_attachment.html.erb

@@ -0,0 +1,5 @@
+<h1>Inline Image</h1>
+
+<%= image_tag attachments['logo.png'].url %>
+
+<p>This is an image that is inline</p>

actionmailer/test/fixtures/base_mailer/inline_attachment.text.erb

@@ -0,0 +1,4 @@
+Inline Image
+
+No image for you
+

actionmailer/test/fixtures/base_mailer/plain_text_only.text.erb

@@ -0,0 +1 @@
+Testing

actionmailer/test/fixtures/base_mailer/welcome.erb

@@ -0,0 +1 @@
+Welcome

actionmailer/test/fixtures/helper_mailer/use_example_helper.erb

@@ -1 +0,0 @@
-So, <%= example_format(@text) %>

actionmailer/test/fixtures/helper_mailer/use_helper.erb

@@ -1 +0,0 @@
-Hello, <%= person_name %>. Thanks for registering!

actionmailer/test/fixtures/helper_mailer/use_helper_method.erb

@@ -1 +0,0 @@
-This message brought to you by <%= name_of_the_mailer_class %>.

actionmailer/test/fixtures/helper_mailer/use_mail_helper.erb

@@ -1,5 +0,0 @@
-From "Romeo and Juliet":
-
-<%= block_format @text %>
-
-Good ol' Shakespeare.

actionmailer/test/fixtures/helpers/example_helper.rb

@@ -1,5 +0,0 @@
-module ExampleHelper
-  def example_format(text)
-    "<em><strong><small>#{text}</small></strong></em>"
-  end
-end

actionmailer/test/fixtures/layouts/different_layout.html.erb

@@ -0,0 +1 @@
+HTML -- <%= yield %>

actionmailer/test/fixtures/layouts/different_layout.text.erb

@@ -0,0 +1 @@
+PLAIN -- <%= yield %>