jro_apps/redmine Commit - r9455:7af8d7caf064

replace Mailer deliver syntax to Rails3 style...

Toshi MARUYAMA -

r9455:7af8d7caf064

parent child

Context file:

r9455:7af8d7caf064

Collapse all files

app/controllers/account_controller.rb +3 -3

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class AccountController < ApplicationController
               helper :custom_fields
               include CustomFieldsHelper
               # prevents login action to be filtered by check_if_login_required application scope filter
               skip_before_filter :check_if_login_required
               # Login request and validation
               def login
                 if request.get?
                   logout_user
                 else
                   authenticate_user
                 end
               rescue AuthSourceException => e
                 logger.error "An error occured when authenticating #{params[:username]}: #{e.message}"
                 render_error :message => e.message
               end
               # Log out current user and redirect to welcome page
               def logout
                 logout_user
                 redirect_to home_url
               end
               # Enable user to choose a new password
               def lost_password
                 redirect_to(home_url) && return unless Setting.lost_password?
                 if params[:token]
                   @token = Token.find_by_action_and_value("recovery", params[:token])
                   redirect_to(home_url) && return unless @token and !@token.expired?
                   @user = @token.user
                   if request.post?
                     @user.password, @user.password_confirmation = params[:new_password], params[:new_password_confirmation]
                     if @user.save
                       @token.destroy
                       flash[:notice] = l(:notice_account_password_updated)
                       redirect_to :action => 'login'
                       return
                     end
                   end
                   render :template => "account/password_recovery"
                   return
                 else
                   if request.post?
                     user = User.find_by_mail(params[:mail])
                     # user not found in db
                     (flash.now[:error] = l(:notice_account_unknown_email); return) unless user
                     # user uses an external authentification
                     (flash.now[:error] = l(:notice_can_t_change_password); return) if user.auth_source_id
                     # create a new token for password recovery
                     token = Token.new(:user => user, :action => "recovery")
                     if token.save
-                      Mailer.deliver_lost_password(token)
+                      Mailer.lost_password(token).deliver
                       flash[:notice] = l(:notice_account_lost_email_sent)
                       redirect_to :action => 'login'
                       return
                     end
                   end
                 end
               end
               # User self-registration
               def register
                 redirect_to(home_url) && return unless Setting.self_registration? || session[:auth_source_registration]
                 if request.get?
                   session[:auth_source_registration] = nil
                   @user = User.new(:language => Setting.default_language)
                 else
                   @user = User.new
                   @user.safe_attributes = params[:user]
                   @user.admin = false
                   @user.register
                   if session[:auth_source_registration]
                     @user.activate
                     @user.login = session[:auth_source_registration][:login]
                     @user.auth_source_id = session[:auth_source_registration][:auth_source_id]
                     if @user.save
                       session[:auth_source_registration] = nil
                       self.logged_user = @user
                       flash[:notice] = l(:notice_account_activated)
                       redirect_to :controller => 'my', :action => 'account'
                     end
                   else
                     @user.login = params[:user][:login]
                     @user.password, @user.password_confirmation = params[:user][:password], params[:user][:password_confirmation]
                     case Setting.self_registration
                     when '1'
                       register_by_email_activation(@user)
                     when '3'
                       register_automatically(@user)
                     else
                       register_manually_by_administrator(@user)
                     end
                   end
                 end
               end
               # Token based account activation
               def activate
                 redirect_to(home_url) && return unless Setting.self_registration? && params[:token]
                 token = Token.find_by_action_and_value('register', params[:token])
                 redirect_to(home_url) && return unless token and !token.expired?
                 user = token.user
                 redirect_to(home_url) && return unless user.registered?
                 user.activate
                 if user.save
                   token.destroy
                   flash[:notice] = l(:notice_account_activated)
                 end
                 redirect_to :action => 'login'
               end
               private
               def authenticate_user
                 if Setting.openid? && using_open_id?
                   open_id_authenticate(params[:openid_url])
                 else
                   password_authentication
                 end
               end
               def password_authentication
                 user = User.try_to_login(params[:username], params[:password])
                 if user.nil?
                   invalid_credentials
                 elsif user.new_record?
                   onthefly_creation_failed(user, {:login => user.login, :auth_source_id => user.auth_source_id })
                 else
                   # Valid user
                   successful_authentication(user)
                 end
               end
               def open_id_authenticate(openid_url)
                 authenticate_with_open_id(openid_url, :required => [:nickname, :fullname, :email], :return_to => signin_url, :method => :post) do |result, identity_url, registration|
                   if result.successful?
                     user = User.find_or_initialize_by_identity_url(identity_url)
                     if user.new_record?
                       # Self-registration off
                       redirect_to(home_url) && return unless Setting.self_registration?
                       # Create on the fly
                       user.login = registration['nickname'] unless registration['nickname'].nil?
                       user.mail = registration['email'] unless registration['email'].nil?
                       user.firstname, user.lastname = registration['fullname'].split(' ') unless registration['fullname'].nil?
                       user.random_password
                       user.register
                       case Setting.self_registration
                       when '1'
                         register_by_email_activation(user) do
                           onthefly_creation_failed(user)
                         end
                       when '3'
                         register_automatically(user) do
                           onthefly_creation_failed(user)
                         end
                       else
                         register_manually_by_administrator(user) do
                           onthefly_creation_failed(user)
                         end
                       end
                     else
                       # Existing record
                       if user.active?
                         successful_authentication(user)
                       else
                         account_pending
                       end
                     end
                   end
                 end
               end
               def successful_authentication(user)
                 # Valid user
                 self.logged_user = user
                 # generate a key and set cookie if autologin
                 if params[:autologin] && Setting.autologin?
                   set_autologin_cookie(user)
                 end
                 call_hook(:controller_account_success_authentication_after, {:user => user })
                 redirect_back_or_default :controller => 'my', :action => 'page'
               end
               def set_autologin_cookie(user)
                 token = Token.create(:user => user, :action => 'autologin')
                 cookie_name = Redmine::Configuration['autologin_cookie_name'] || 'autologin'
                 cookie_options = {
                   :value => token.value,
                   :expires => 1.year.from_now,
                   :path => (Redmine::Configuration['autologin_cookie_path'] || '/'),
                   :secure => (Redmine::Configuration['autologin_cookie_secure'] ? true : false),
                   :httponly => true
                 }
                 cookies[cookie_name] = cookie_options
               end
               # Onthefly creation failed, display the registration form to fill/fix attributes
               def onthefly_creation_failed(user, auth_source_options = { })
                 @user = user
                 session[:auth_source_registration] = auth_source_options unless auth_source_options.empty?
                 render :action => 'register'
               end
               def invalid_credentials
                 logger.warn "Failed login for '#{params[:username]}' from #{request.remote_ip} at #{Time.now.utc}"
                 flash.now[:error] = l(:notice_account_invalid_creditentials)
               end
               # Register a user for email activation.
               #
               # Pass a block for behavior when a user fails to save
               def register_by_email_activation(user, &block)
                 token = Token.new(:user => user, :action => "register")
                 if user.save and token.save
-                  Mailer.deliver_register(token)
+                  Mailer.register(token).deliver
                   flash[:notice] = l(:notice_account_register_done)
                   redirect_to :action => 'login'
                 else
                   yield if block_given?
                 end
               end
               # Automatically register a user
               #
               # Pass a block for behavior when a user fails to save
               def register_automatically(user, &block)
                 # Automatic activation
                 user.activate
                 user.last_login_on = Time.now
                 if user.save
                   self.logged_user = user
                   flash[:notice] = l(:notice_account_activated)
                   redirect_to :controller => 'my', :action => 'account'
                 else
                   yield if block_given?
                 end
               end
               # Manual activation by the administrator
               #
               # Pass a block for behavior when a user fails to save
               def register_manually_by_administrator(user, &block)
                 if user.save
                   # Sends an email to the administrators
-                  Mailer.deliver_account_activation_request(user)
+                  Mailer.account_activation_request(user).deliver
                   account_pending
                 else
                   yield if block_given?
                 end
               end
               def account_pending
                 flash[:notice] = l(:notice_account_pending)
                 redirect_to :action => 'login'
               end
             end

app/controllers/admin_controller.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class AdminController < ApplicationController
               layout 'admin'
               menu_item :projects, :only => :projects
               menu_item :plugins, :only => :plugins
               menu_item :info, :only => :info
               before_filter :require_admin
               helper :sort
               include SortHelper
               def index
                 @no_configuration_data = Redmine::DefaultData::Loader::no_data?
               end
               def projects
                 @status = params[:status] || 1
                 scope = Project.status(@status)
                 scope = scope.like(params[:name]) if params[:name].present?
                 @projects = scope.all(:order => 'lft')
                 render :action => "projects", :layout => false if request.xhr?
               end
               def plugins
                 @plugins = Redmine::Plugin.all
               end
               # Loads the default configuration
               # (roles, trackers, statuses, workflow, enumerations)
               def default_configuration
                 if request.post?
                   begin
                     Redmine::DefaultData::Loader::load(params[:lang])
                     flash[:notice] = l(:notice_default_data_loaded)
                   rescue Exception => e
                     flash[:error] = l(:error_can_t_load_default_data, e.message)
                   end
                 end
                 redirect_to :action => 'index'
               end
               def test_email
                 raise_delivery_errors = ActionMailer::Base.raise_delivery_errors
                 # Force ActionMailer to raise delivery errors so we can catch it
                 ActionMailer::Base.raise_delivery_errors = true
                 begin
-                  @test = Mailer.deliver_test_email(User.current)
+                  @test = Mailer.test_email(User.current).deliver
                   flash[:notice] = l(:notice_email_sent, User.current.mail)
                 rescue Exception => e
                   flash[:error] = l(:notice_email_error, e.message)
                 end
                 ActionMailer::Base.raise_delivery_errors = raise_delivery_errors
                 redirect_to :controller => 'settings', :action => 'edit', :tab => 'notifications'
               end
               def info
                 @db_adapter_name = ActiveRecord::Base.connection.adapter_name
                 @checklist = [
                   [:text_default_administrator_account_changed, User.default_admin_account_changed?],
                   [:text_file_repository_writable, File.writable?(Attachment.storage_path)],
                   [:text_plugin_assets_writable,   File.writable?(Redmine::Plugin.public_directory)],
                   [:text_rmagick_available,        Object.const_defined?(:Magick)]
                 ]
               end
             end

app/controllers/documents_controller.rb +3 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class DocumentsController < ApplicationController
               default_search_scope :documents
               model_object Document
               before_filter :find_project_by_project_id, :only => [:index, :new, :create]
               before_filter :find_model_object, :except => [:index, :new, :create]
               before_filter :find_project_from_association, :except => [:index, :new, :create]
               before_filter :authorize
               helper :attachments
               def index
                 @sort_by = %w(category date title author).include?(params[:sort_by]) ? params[:sort_by] : 'category'
                 documents = @project.documents.find :all, :include => [:attachments, :category]
                 case @sort_by
                 when 'date'
                   @grouped = documents.group_by {|d| d.updated_on.to_date }
                 when 'title'
                   @grouped = documents.group_by {|d| d.title.first.upcase}
                 when 'author'
                   @grouped = documents.select{|d| d.attachments.any?}.group_by {|d| d.attachments.last.author}
                 else
                   @grouped = documents.group_by(&:category)
                 end
                 @document = @project.documents.build
                 render :layout => false if request.xhr?
               end
               def show
                 @attachments = @document.attachments.find(:all, :order => "created_on DESC")
               end
               def new
                 @document = @project.documents.build
                 @document.safe_attributes = params[:document]
               end
               def create
                 @document = @project.documents.build
                 @document.safe_attributes = params[:document]
                 @document.save_attachments(params[:attachments])
                 if @document.save
                   render_attachment_warning_if_needed(@document)
                   flash[:notice] = l(:notice_successful_create)
                   redirect_to :action => 'index', :project_id => @project
                 else
                   render :action => 'new'
                 end
               end
               def edit
               end
               def update
                 @document.safe_attributes = params[:document]
                 if request.put? and @document.save
                   flash[:notice] = l(:notice_successful_update)
                   redirect_to :action => 'show', :id => @document
                 else
                   render :action => 'edit'
                 end
               end
               def destroy
                 @document.destroy if request.delete?
                 redirect_to :controller => 'documents', :action => 'index', :project_id => @project
               end
               def add_attachment
                 attachments = Attachment.attach_files(@document, params[:attachments])
                 render_attachment_warning_if_needed(@document)
-                Mailer.deliver_attachments_added(attachments[:files]) if attachments.present? && attachments[:files].present? && Setting.notified_events.include?('document_added')
+                if attachments.present? && attachments[:files].present? && Setting.notified_events.include?('document_added')
+                  Mailer.attachments_added(attachments[:files]).deliver
+                end
                 redirect_to :action => 'show', :id => @document
               end
             end

app/controllers/files_controller.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class FilesController < ApplicationController
               menu_item :files
               before_filter :find_project_by_project_id
               before_filter :authorize
               helper :sort
               include SortHelper
               def index
                 sort_init 'filename', 'asc'
                 sort_update 'filename' => "#{Attachment.table_name}.filename",
                             'created_on' => "#{Attachment.table_name}.created_on",
                             'size' => "#{Attachment.table_name}.filesize",
                             'downloads' => "#{Attachment.table_name}.downloads"
                 @containers = [ Project.find(@project.id, :include => :attachments, :order => sort_clause)]
                 @containers += @project.versions.find(:all, :include => :attachments, :order => sort_clause).sort.reverse
                 render :layout => !request.xhr?
               end
               def new
                 @versions = @project.versions.sort
               end
               def create
                 container = (params[:version_id].blank? ? @project : @project.versions.find_by_id(params[:version_id]))
                 attachments = Attachment.attach_files(container, params[:attachments])
                 render_attachment_warning_if_needed(container)
                 if !attachments.empty? && !attachments[:files].blank? && Setting.notified_events.include?('file_added')
-                  Mailer.deliver_attachments_added(attachments[:files])
+                  Mailer.attachments_added(attachments[:files]).deliver
                 end
                 redirect_to project_files_path(@project)
               end
             end

app/controllers/users_controller.rb +3 -3

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class UsersController < ApplicationController
               layout 'admin'
               before_filter :require_admin, :except => :show
               before_filter :find_user, :only => [:show, :edit, :update, :destroy, :edit_membership, :destroy_membership]
               accept_api_auth :index, :show, :create, :update, :destroy
               helper :sort
               include SortHelper
               helper :custom_fields
               include CustomFieldsHelper
               def index
                 sort_init 'login', 'asc'
                 sort_update %w(login firstname lastname mail admin created_on last_login_on)
                 case params[:format]
                 when 'xml', 'json'
                   @offset, @limit = api_offset_and_limit
                 else
                   @limit = per_page_option
                 end
                 @status = params[:status] || 1
                 scope = User.logged.status(@status)
                 scope = scope.like(params[:name]) if params[:name].present?
                 scope = scope.in_group(params[:group_id]) if params[:group_id].present?
                 @user_count = scope.count
                 @user_pages = Paginator.new self, @user_count, @limit, params['page']
                 @offset ||= @user_pages.current.offset
                 @users =  scope.find :all,
                                     :order => sort_clause,
                                     :limit  =>  @limit,
                                     :offset =>  @offset
                 respond_to do |format|
                   format.html {
                     @groups = Group.all.sort
                     render :layout => !request.xhr?
                   }
                   format.api
                 end
               end
               def show
                 # show projects based on current user visibility
                 @memberships = @user.memberships.all(:conditions => Project.visible_condition(User.current))
                 events = Redmine::Activity::Fetcher.new(User.current, :author => @user).events(nil, nil, :limit => 10)
                 @events_by_day = events.group_by(&:event_date)
                 unless User.current.admin?
                   if !@user.active? || (@user != User.current  && @memberships.empty? && events.empty?)
                     render_404
                     return
                   end
                 end
                 respond_to do |format|
                   format.html { render :layout => 'base' }
                   format.api
                 end
               end
               def new
                 @user = User.new(:language => Setting.default_language, :mail_notification => Setting.default_notification_option)
                 @auth_sources = AuthSource.find(:all)
               end
               def create
                 @user = User.new(:language => Setting.default_language, :mail_notification => Setting.default_notification_option)
                 @user.safe_attributes = params[:user]
                 @user.admin = params[:user][:admin] || false
                 @user.login = params[:user][:login]
                 @user.password, @user.password_confirmation = params[:user][:password], params[:user][:password_confirmation] unless @user.auth_source_id
                 if @user.save
                   @user.pref.attributes = params[:pref]
                   @user.pref[:no_self_notified] = (params[:no_self_notified] == '1')
                   @user.pref.save
                   @user.notified_project_ids = (@user.mail_notification == 'selected' ? params[:notified_project_ids] : [])
-                  Mailer.deliver_account_information(@user, params[:user][:password]) if params[:send_information]
+                  Mailer.account_information(@user, params[:user][:password]).deliver if params[:send_information]
                   respond_to do |format|
                     format.html {
                       flash[:notice] = l(:notice_successful_create)
                       redirect_to(params[:continue] ?
                         {:controller => 'users', :action => 'new'} :
                         {:controller => 'users', :action => 'edit', :id => @user}
                       )
                     }
                     format.api  { render :action => 'show', :status => :created, :location => user_url(@user) }
                   end
                 else
                   @auth_sources = AuthSource.find(:all)
                   # Clear password input
                   @user.password = @user.password_confirmation = nil
                   respond_to do |format|
                     format.html { render :action => 'new' }
                     format.api  { render_validation_errors(@user) }
                   end
                 end
               end
               def edit
                 @auth_sources = AuthSource.find(:all)
                 @membership ||= Member.new
               end
               def update
                 @user.admin = params[:user][:admin] if params[:user][:admin]
                 @user.login = params[:user][:login] if params[:user][:login]
                 if params[:user][:password].present? && (@user.auth_source_id.nil? || params[:user][:auth_source_id].blank?)
                   @user.password, @user.password_confirmation = params[:user][:password], params[:user][:password_confirmation]
                 end
                 @user.safe_attributes = params[:user]
                 # Was the account actived ? (do it before User#save clears the change)
                 was_activated = (@user.status_change == [User::STATUS_REGISTERED, User::STATUS_ACTIVE])
                 # TODO: Similar to My#account
                 @user.pref.attributes = params[:pref]
                 @user.pref[:no_self_notified] = (params[:no_self_notified] == '1')
                 if @user.save
                   @user.pref.save
                   @user.notified_project_ids = (@user.mail_notification == 'selected' ? params[:notified_project_ids] : [])
                   if was_activated
-                    Mailer.deliver_account_activated(@user)
+                    Mailer.account_activated(@user).deliver
                   elsif @user.active? && params[:send_information] && !params[:user][:password].blank? && @user.auth_source_id.nil?
-                    Mailer.deliver_account_information(@user, params[:user][:password])
+                    Mailer.account_information(@user, params[:user][:password]).deliver
                   end
                   respond_to do |format|
                     format.html {
                       flash[:notice] = l(:notice_successful_update)
                       redirect_to_referer_or edit_user_path(@user)
                     }
                     format.api  { head :ok }
                   end
                 else
                   @auth_sources = AuthSource.find(:all)
                   @membership ||= Member.new
                   # Clear password input
                   @user.password = @user.password_confirmation = nil
                   respond_to do |format|
                     format.html { render :action => :edit }
                     format.api  { render_validation_errors(@user) }
                   end
                 end
               end
               def destroy
                 @user.destroy
                 respond_to do |format|
                   format.html { redirect_to(users_url) }
                   format.api  { head :ok }
                 end
               end
               def edit_membership
                 @membership = Member.edit_membership(params[:membership_id], params[:membership], @user)
                 @membership.save
                 respond_to do |format|
                   if @membership.valid?
                     format.html { redirect_to :controller => 'users', :action => 'edit', :id => @user, :tab => 'memberships' }
                     format.js {
                       render(:update) {|page|
                         page.replace_html "tab-content-memberships", :partial => 'users/memberships'
                         page.visual_effect(:highlight, "member-#{@membership.id}")
                       }
                     }
                   else
                     format.js {
                       render(:update) {|page|
                         page.alert(l(:notice_failed_to_save_members, :errors => @membership.errors.full_messages.join(', ')))
                       }
                     }
                   end
                 end
               end
               def destroy_membership
                 @membership = Member.find(params[:membership_id])
                 if @membership.deletable?
                   @membership.destroy
                 end
                 respond_to do |format|
                   format.html { redirect_to :controller => 'users', :action => 'edit', :id => @user, :tab => 'memberships' }
                   format.js { render(:update) {|page| page.replace_html "tab-content-memberships", :partial => 'users/memberships'} }
                 end
               end
               private
               def find_user
                 if params[:id] == 'current'
                   require_login || return
                   @user = User.current
                 else
                   @user = User.find(params[:id])
                 end
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
             end

app/models/comment_observer.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class CommentObserver < ActiveRecord::Observer
               def after_create(comment)
                 if comment.commented.is_a?(News) && Setting.notified_events.include?('news_comment_added')
-                  Mailer.deliver_news_comment_added(comment)
+                  Mailer.news_comment_added(comment).deliver
                 end
               end
             end

app/models/document_observer.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class DocumentObserver < ActiveRecord::Observer
               def after_create(document)
-                Mailer.deliver_document_added(document) if Setting.notified_events.include?('document_added')
+                Mailer.document_added(document).deliver if Setting.notified_events.include?('document_added')
               end
             end

app/models/issue_observer.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class IssueObserver < ActiveRecord::Observer
               def after_create(issue)
-                Mailer.deliver_issue_add(issue) if Setting.notified_events.include?('issue_added')
+                Mailer.issue_add(issue).deliver if Setting.notified_events.include?('issue_added')
               end
             end

app/models/journal_observer.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class JournalObserver < ActiveRecord::Observer
               def after_create(journal)
                 if journal.notify? &&
                     (Setting.notified_events.include?('issue_updated') ||
                       (Setting.notified_events.include?('issue_note_added') && journal.notes.present?) ||
                       (Setting.notified_events.include?('issue_status_updated') && journal.new_status.present?) ||
                       (Setting.notified_events.include?('issue_priority_updated') && journal.new_value_for('priority_id').present?)
                     )
-                  Mailer.deliver_issue_edit(journal)
+                  Mailer.issue_edit(journal).deliver
                 end
               end
             end

app/models/mail_handler.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class MailHandler < ActionMailer::Base
               include ActionView::Helpers::SanitizeHelper
               include Redmine::I18n
               class UnauthorizedAction < StandardError; end
               class MissingInformation < StandardError; end
               attr_reader :email, :user
               def self.receive(email, options={})
                 @@handler_options = options.dup
                 @@handler_options[:issue] ||= {}
                 if @@handler_options[:allow_override].is_a?(String)
                   @@handler_options[:allow_override] = @@handler_options[:allow_override].split(',').collect(&:strip)
                 end
                 @@handler_options[:allow_override] ||= []
                 # Project needs to be overridable if not specified
                 @@handler_options[:allow_override] << 'project' unless @@handler_options[:issue].has_key?(:project)
                 # Status overridable by default
                 @@handler_options[:allow_override] << 'status' unless @@handler_options[:issue].has_key?(:status)
                 @@handler_options[:no_permission_check] = (@@handler_options[:no_permission_check].to_s == '1' ? true : false)
                 email.force_encoding('ASCII-8BIT') if email.respond_to?(:force_encoding)
                 super(email)
               end
               def logger
                 Rails.logger
               end
               cattr_accessor :ignored_emails_headers
               @@ignored_emails_headers = {
                 'X-Auto-Response-Suppress' => 'OOF',
                 'Auto-Submitted' => 'auto-replied'
               }
               # Processes incoming emails
               # Returns the created object (eg. an issue, a message) or false
               def receive(email)
                 @email = email
                 sender_email = email.from.to_a.first.to_s.strip
                 # Ignore emails received from the application emission address to avoid hell cycles
                 if sender_email.downcase == Setting.mail_from.to_s.strip.downcase
                   if logger && logger.info
                     logger.info  "MailHandler: ignoring email from Redmine emission address [#{sender_email}]"
                   end
                   return false
                 end
                 # Ignore auto generated emails
                 self.class.ignored_emails_headers.each do |key, ignored_value|
                   value = email.header[key]
                   if value && value.to_s.downcase == ignored_value.downcase
                     if logger && logger.info
                       logger.info "MailHandler: ignoring email with #{key}:#{value} header"
                     end
                     return false
                   end
                 end
                 @user = User.find_by_mail(sender_email) if sender_email.present?
                 if @user && !@user.active?
                   if logger && logger.info
                     logger.info  "MailHandler: ignoring email from non-active user [#{@user.login}]"
                   end
                   return false
                 end
                 if @user.nil?
                   # Email was submitted by an unknown user
                   case @@handler_options[:unknown_user]
                   when 'accept'
                     @user = User.anonymous
                   when 'create'
                     @user = create_user_from_email
                     if @user
                       if logger && logger.info
                         logger.info "MailHandler: [#{@user.login}] account created"
                       end
-                      Mailer.deliver_account_information(@user, @user.password)
+                      Mailer.account_information(@user, @user.password).deliver
                     else
                       if logger && logger.error
                         logger.error "MailHandler: could not create account for [#{sender_email}]"
                       end
                       return false
                     end
                   else
                     # Default behaviour, emails from unknown users are ignored
                     if logger && logger.info
                       logger.info  "MailHandler: ignoring email from unknown user [#{sender_email}]"
                     end
                     return false
                   end
                 end
                 User.current = @user
                 dispatch
               end
               private
               MESSAGE_ID_RE = %r{^<?redmine\.([a-z0-9_]+)\-(\d+)\.\d+@}
               ISSUE_REPLY_SUBJECT_RE = %r{\[[^\]]*#(\d+)\]}
               MESSAGE_REPLY_SUBJECT_RE = %r{\[[^\]]*msg(\d+)\]}
               def dispatch
                 headers = [email.in_reply_to, email.references].flatten.compact
                 if headers.detect {|h| h.to_s =~ MESSAGE_ID_RE}
                   klass, object_id = $1, $2.to_i
                   method_name = "receive_#{klass}_reply"
                   if self.class.private_instance_methods.collect(&:to_s).include?(method_name)
                     send method_name, object_id
                   else
                     # ignoring it
                   end
                 elsif m = email.subject.match(ISSUE_REPLY_SUBJECT_RE)
                   receive_issue_reply(m[1].to_i)
                 elsif m = email.subject.match(MESSAGE_REPLY_SUBJECT_RE)
                   receive_message_reply(m[1].to_i)
                 else
                   dispatch_to_default
                 end
               rescue ActiveRecord::RecordInvalid => e
                 # TODO: send a email to the user
                 logger.error e.message if logger
                 false
               rescue MissingInformation => e
                 logger.error "MailHandler: missing information from #{user}: #{e.message}" if logger
                 false
               rescue UnauthorizedAction => e
                 logger.error "MailHandler: unauthorized attempt from #{user}" if logger
                 false
               end
               def dispatch_to_default
                 receive_issue
               end
               # Creates a new issue
               def receive_issue
                 project = target_project
                 # check permission
                 unless @@handler_options[:no_permission_check]
                   raise UnauthorizedAction unless user.allowed_to?(:add_issues, project)
                 end
                 issue = Issue.new(:author => user, :project => project)
                 issue.safe_attributes = issue_attributes_from_keywords(issue)
                 issue.safe_attributes = {'custom_field_values' => custom_field_values_from_keywords(issue)}
                 issue.subject = email.subject.to_s.chomp[0,255]
                 if issue.subject.blank?
                   issue.subject = '(no subject)'
                 end
                 issue.description = cleaned_up_text_body
                 # add To and Cc as watchers before saving so the watchers can reply to Redmine
                 add_watchers(issue)
                 issue.save!
                 add_attachments(issue)
                 logger.info "MailHandler: issue ##{issue.id} created by #{user}" if logger && logger.info
                 issue
               end
               # Adds a note to an existing issue
               def receive_issue_reply(issue_id)
                 issue = Issue.find_by_id(issue_id)
                 return unless issue
                 # check permission
                 unless @@handler_options[:no_permission_check]
                   unless user.allowed_to?(:add_issue_notes, issue.project) ||
                            user.allowed_to?(:edit_issues, issue.project)
                     raise UnauthorizedAction
                   end
                 end
                 # ignore CLI-supplied defaults for new issues
                 @@handler_options[:issue].clear
                 journal = issue.init_journal(user)
                 issue.safe_attributes = issue_attributes_from_keywords(issue)
                 issue.safe_attributes = {'custom_field_values' => custom_field_values_from_keywords(issue)}
                 journal.notes = cleaned_up_text_body
                 add_attachments(issue)
                 issue.save!
                 if logger && logger.info
                   logger.info "MailHandler: issue ##{issue.id} updated by #{user}"
                 end
                 journal
               end
               # Reply will be added to the issue
               def receive_journal_reply(journal_id)
                 journal = Journal.find_by_id(journal_id)
                 if journal && journal.journalized_type == 'Issue'
                   receive_issue_reply(journal.journalized_id)
                 end
               end
               # Receives a reply to a forum message
               def receive_message_reply(message_id)
                 message = Message.find_by_id(message_id)
                 if message
                   message = message.root
                   unless @@handler_options[:no_permission_check]
                     raise UnauthorizedAction unless user.allowed_to?(:add_messages, message.project)
                   end
                   if !message.locked?
                     reply = Message.new(:subject => email.subject.gsub(%r{^.*msg\d+\]}, '').strip,
                                         :content => cleaned_up_text_body)
                     reply.author = user
                     reply.board = message.board
                     message.children << reply
                     add_attachments(reply)
                     reply
                   else
                     if logger && logger.info
                       logger.info "MailHandler: ignoring reply from [#{sender_email}] to a locked topic"
                     end
                   end
                 end
               end
               def add_attachments(obj)
                 if email.attachments && email.attachments.any?
                   email.attachments.each do |attachment|
                     obj.attachments << Attachment.create(:container => obj,
                                       :file => attachment.decoded,
                                       :filename => attachment.filename,
                                       :author => user,
                                       :content_type => attachment.mime_type)
                   end
                 end
               end
               # Adds To and Cc as watchers of the given object if the sender has the
               # appropriate permission
               def add_watchers(obj)
                 if user.allowed_to?("add_#{obj.class.name.underscore}_watchers".to_sym, obj.project)
                   addresses = [email.to, email.cc].flatten.compact.uniq.collect {|a| a.strip.downcase}
                   unless addresses.empty?
                     watchers = User.active.find(:all, :conditions => ['LOWER(mail) IN (?)', addresses])
                     watchers.each {|w| obj.add_watcher(w)}
                   end
                 end
               end
               def get_keyword(attr, options={})
                 @keywords ||= {}
                 if @keywords.has_key?(attr)
                   @keywords[attr]
                 else
                   @keywords[attr] = begin
                     if (options[:override] || @@handler_options[:allow_override].include?(attr.to_s)) &&
                           (v = extract_keyword!(plain_text_body, attr, options[:format]))
                       v
                     elsif !@@handler_options[:issue][attr].blank?
                       @@handler_options[:issue][attr]
                     end
                   end
                 end
               end
               # Destructively extracts the value for +attr+ in +text+
               # Returns nil if no matching keyword found
               def extract_keyword!(text, attr, format=nil)
                 keys = [attr.to_s.humanize]
                 if attr.is_a?(Symbol)
                   if user && user.language.present?
                     keys << l("field_#{attr}", :default => '', :locale =>  user.language)
                   end
                   if Setting.default_language.present?
                     keys << l("field_#{attr}", :default => '', :locale =>  Setting.default_language)
                   end
                 end
                 keys.reject! {|k| k.blank?}
                 keys.collect! {|k| Regexp.escape(k)}
                 format ||= '.+'
                 keyword = nil
                 regexp = /^(#{keys.join('|')})[ \t]*:[ \t]*(#{format})\s*$/i
                 if m = text.match(regexp)
                   keyword = m[2].strip
                   text.gsub!(regexp, '')
                 end
                 keyword
               end
               def target_project
                 # TODO: other ways to specify project:
                 # * parse the email To field
                 # * specific project (eg. Setting.mail_handler_target_project)
                 target = Project.find_by_identifier(get_keyword(:project))
                 raise MissingInformation.new('Unable to determine target project') if target.nil?
                 target
               end
               # Returns a Hash of issue attributes extracted from keywords in the email body
               def issue_attributes_from_keywords(issue)
                 assigned_to = (k = get_keyword(:assigned_to, :override => true)) && find_assignee_from_keyword(k, issue)
                 attrs = {
                   'tracker_id' => (k = get_keyword(:tracker)) && issue.project.trackers.named(k).first.try(:id),
                   'status_id' =>  (k = get_keyword(:status)) && IssueStatus.named(k).first.try(:id),
                   'priority_id' => (k = get_keyword(:priority)) && IssuePriority.named(k).first.try(:id),
                   'category_id' => (k = get_keyword(:category)) && issue.project.issue_categories.named(k).first.try(:id),
                   'assigned_to_id' => assigned_to.try(:id),
                   'fixed_version_id' => (k = get_keyword(:fixed_version, :override => true)) &&
                                             issue.project.shared_versions.named(k).first.try(:id),
                   'start_date' => get_keyword(:start_date, :override => true, :format => '\d{4}-\d{2}-\d{2}'),
                   'due_date' => get_keyword(:due_date, :override => true, :format => '\d{4}-\d{2}-\d{2}'),
                   'estimated_hours' => get_keyword(:estimated_hours, :override => true),
                   'done_ratio' => get_keyword(:done_ratio, :override => true, :format => '(\d|10)?0')
                 }.delete_if {|k, v| v.blank? }
                 if issue.new_record? && attrs['tracker_id'].nil?
                   attrs['tracker_id'] = issue.project.trackers.find(:first).try(:id)
                 end
                 attrs
               end
               # Returns a Hash of issue custom field values extracted from keywords in the email body
               def custom_field_values_from_keywords(customized)
                 customized.custom_field_values.inject({}) do |h, v|
                   if value = get_keyword(v.custom_field.name, :override => true)
                     h[v.custom_field.id.to_s] = value
                   end
                   h
                 end
               end
               # Returns the text/plain part of the email
               # If not found (eg. HTML-only email), returns the body with tags removed
               def plain_text_body
                 return @plain_text_body unless @plain_text_body.nil?
                 part = email.text_part || email.html_part || email
                 @plain_text_body = Redmine::CodesetUtil.to_utf8(part.body.decoded, part.charset)
                 if @plain_text_body.respond_to?(:force_encoding)
                  # @plain_text_body = @plain_text_body.force_encoding(@email.charset).encode("UTF-8")
                 end
                 # strip html tags and remove doctype directive
                 @plain_text_body = strip_tags(@plain_text_body.strip)
                 @plain_text_body.sub! %r{^<!DOCTYPE .*$}, ''
                 @plain_text_body
               end
               def cleaned_up_text_body
                 cleanup_body(plain_text_body)
               end
               def self.full_sanitizer
                 @full_sanitizer ||= HTML::FullSanitizer.new
               end
               def self.assign_string_attribute_with_limit(object, attribute, value, limit=nil)
                 limit ||= object.class.columns_hash[attribute.to_s].limit || 255
                 value = value.to_s.slice(0, limit)
                 object.send("#{attribute}=", value)
               end
               # Returns a User from an email address and a full name
               def self.new_user_from_attributes(email_address, fullname=nil)
                 user = User.new
                 # Truncating the email address would result in an invalid format
                 user.mail = email_address
                 assign_string_attribute_with_limit(user, 'login', email_address, User::LOGIN_LENGTH_LIMIT)
                 names = fullname.blank? ? email_address.gsub(/@.*$/, '').split('.') : fullname.split
                 assign_string_attribute_with_limit(user, 'firstname', names.shift)
                 assign_string_attribute_with_limit(user, 'lastname', names.join(' '))
                 user.lastname = '-' if user.lastname.blank?
                 password_length = [Setting.password_min_length.to_i, 10].max
                 user.password = Redmine::Utils.random_hex(password_length / 2 + 1)
                 user.language = Setting.default_language
                 unless user.valid?
                   user.login = "user#{Redmine::Utils.random_hex(6)}" unless user.errors[:login].blank?
                   user.firstname = "-" unless user.errors[:firstname].blank?
                   user.lastname  = "-" unless user.errors[:lastname].blank?
                 end
                 user
               end
               # Creates a User for the +email+ sender
               # Returns the user or nil if it could not be created
               def create_user_from_email
                 from = email.header['from'].to_s
                 addr, name = from, nil
                 if m = from.match(/^"?(.+?)"?\s+<(.+@.+)>$/)
                   addr, name = m[2], m[1]
                 end
                 if addr.present?
                   user = self.class.new_user_from_attributes(addr, name)
                   if user.save
                     user
                   else
                     logger.error "MailHandler: failed to create User: #{user.errors.full_messages}" if logger
                     nil
                   end
                 else
                   logger.error "MailHandler: failed to create User: no FROM address found" if logger
                   nil
                 end
               end
               # Removes the email body of text after the truncation configurations.
               def cleanup_body(body)
                 delimiters = Setting.mail_handler_body_delimiters.to_s.split(/[\r\n]+/).reject(&:blank?).map {|s| Regexp.escape(s)}
                 unless delimiters.empty?
                   regex = Regexp.new("^[> ]*(#{ delimiters.join('|') })\s*[\r\n].*", Regexp::MULTILINE)
                   body = body.gsub(regex, '')
                 end
                 body.strip
               end
               def find_assignee_from_keyword(keyword, issue)
                 keyword = keyword.to_s.downcase
                 assignable = issue.assignable_users
                 assignee = nil
                 assignee ||= assignable.detect {|a|
                                a.mail.to_s.downcase == keyword ||
                                  a.login.to_s.downcase == keyword
                              }
                 if assignee.nil? && keyword.match(/ /)
                   firstname, lastname = *(keyword.split) # "First Last Throwaway"
                   assignee ||= assignable.detect {|a|
                                  a.is_a?(User) && a.firstname.to_s.downcase == firstname &&
                                    a.lastname.to_s.downcase == lastname
                                }
                 end
                 if assignee.nil?
                   assignee ||= assignable.detect {|a| a.is_a?(Group) && a.name.downcase == keyword}
                 end
                 assignee
               end
             end

app/models/message_observer.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class MessageObserver < ActiveRecord::Observer
               def after_create(message)
-                Mailer.deliver_message_posted(message) if Setting.notified_events.include?('message_posted')
+                Mailer.message_posted(message).deliver if Setting.notified_events.include?('message_posted')
               end
             end

app/models/news_observer.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class NewsObserver < ActiveRecord::Observer
               def after_create(news)
-                Mailer.deliver_news_added(news) if Setting.notified_events.include?('news_added')
+                Mailer.news_added(news).deliver if Setting.notified_events.include?('news_added')
               end
             end

app/models/wiki_content_observer.rb +2 -2

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             class WikiContentObserver < ActiveRecord::Observer
               def after_create(wiki_content)
-                Mailer.deliver_wiki_content_added(wiki_content) if Setting.notified_events.include?('wiki_content_added')
+                Mailer.wiki_content_added(wiki_content).deliver if Setting.notified_events.include?('wiki_content_added')
               end
               def after_update(wiki_content)
                 if wiki_content.text_changed?
-                  Mailer.deliver_wiki_content_updated(wiki_content) if Setting.notified_events.include?('wiki_content_updated')
+                  Mailer.wiki_content_updated(wiki_content).deliver if Setting.notified_events.include?('wiki_content_updated')
                 end
               end
             end

lib/tasks/email.rake +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             namespace :redmine do
               namespace :email do
                 desc <<-END_DESC
             Read an email from standard input.
             General options:
               unknown_user=ACTION      how to handle emails from an unknown user
                                        ACTION can be one of the following values:
                                        ignore: email is ignored (default)
                                        accept: accept as anonymous user
                                        create: create a user account
               no_permission_check=1    disable permission checking when receiving
                                        the email
             Issue attributes control options:
               project=PROJECT          identifier of the target project
               status=STATUS            name of the target status
               tracker=TRACKER          name of the target tracker
               category=CATEGORY        name of the target category
               priority=PRIORITY        name of the target priority
               allow_override=ATTRS     allow email content to override attributes
                                        specified by previous options
                                        ATTRS is a comma separated list of attributes
             Examples:
               # No project specified. Emails MUST contain the 'Project' keyword:
               rake redmine:email:read RAILS_ENV="production" < raw_email
               # Fixed project and default tracker specified, but emails can override
               # both tracker and priority attributes:
               rake redmine:email:read RAILS_ENV="production" \\
                               project=foo \\
                               tracker=bug \\
                               allow_override=tracker,priority < raw_email
             END_DESC
                 task :read => :environment do
                   options = { :issue => {} }
                   %w(project status tracker category priority).each { |a| options[:issue][a.to_sym] = ENV[a] if ENV[a] }
                   options[:allow_override] = ENV['allow_override'] if ENV['allow_override']
                   options[:unknown_user] = ENV['unknown_user'] if ENV['unknown_user']
                   options[:no_permission_check] = ENV['no_permission_check'] if ENV['no_permission_check']
                   MailHandler.receive(STDIN.read, options)
                 end
                 desc <<-END_DESC
             Read emails from an IMAP server.
             General options:
               unknown_user=ACTION      how to handle emails from an unknown user
                                        ACTION can be one of the following values:
                                        ignore: email is ignored (default)
                                        accept: accept as anonymous user
                                        create: create a user account
               no_permission_check=1    disable permission checking when receiving
                                        the email
             Available IMAP options:
               host=HOST                IMAP server host (default: 127.0.0.1)
               port=PORT                IMAP server port (default: 143)
               ssl=SSL                  Use SSL? (default: false)
               username=USERNAME        IMAP account
               password=PASSWORD        IMAP password
               folder=FOLDER            IMAP folder to read (default: INBOX)
             Issue attributes control options:
               project=PROJECT          identifier of the target project
               status=STATUS            name of the target status
               tracker=TRACKER          name of the target tracker
               category=CATEGORY        name of the target category
               priority=PRIORITY        name of the target priority
               allow_override=ATTRS     allow email content to override attributes
                                        specified by previous options
                                        ATTRS is a comma separated list of attributes
             Processed emails control options:
               move_on_success=MAILBOX  move emails that were successfully received
                                        to MAILBOX instead of deleting them
               move_on_failure=MAILBOX  move emails that were ignored to MAILBOX
             Examples:
               # No project specified. Emails MUST contain the 'Project' keyword:
               rake redmine:email:receive_imap RAILS_ENV="production" \\
                 host=imap.foo.bar username=redmine@example.net password=xxx
               # Fixed project and default tracker specified, but emails can override
               # both tracker and priority attributes:
               rake redmine:email:receive_imap RAILS_ENV="production" \\
                 host=imap.foo.bar username=redmine@example.net password=xxx ssl=1 \\
                 project=foo \\
                 tracker=bug \\
                 allow_override=tracker,priority
             END_DESC
                 task :receive_imap => :environment do
                   imap_options = {:host => ENV['host'],
                                   :port => ENV['port'],
                                   :ssl => ENV['ssl'],
                                   :username => ENV['username'],
                                   :password => ENV['password'],
                                   :folder => ENV['folder'],
                                   :move_on_success => ENV['move_on_success'],
                                   :move_on_failure => ENV['move_on_failure']}
                   options = { :issue => {} }
                   %w(project status tracker category priority).each { |a| options[:issue][a.to_sym] = ENV[a] if ENV[a] }
                   options[:allow_override] = ENV['allow_override'] if ENV['allow_override']
                   options[:unknown_user] = ENV['unknown_user'] if ENV['unknown_user']
                   options[:no_permission_check] = ENV['no_permission_check'] if ENV['no_permission_check']
                   Redmine::IMAP.check(imap_options, options)
                 end
                 desc <<-END_DESC
             Read emails from an POP3 server.
             Available POP3 options:
               host=HOST                POP3 server host (default: 127.0.0.1)
               port=PORT                POP3 server port (default: 110)
               username=USERNAME        POP3 account
               password=PASSWORD        POP3 password
               apop=1                   use APOP authentication (default: false)
               delete_unprocessed=1     delete messages that could not be processed
                                        successfully from the server (default
                                        behaviour is to leave them on the server)
             See redmine:email:receive_imap for more options and examples.
             END_DESC
                 task :receive_pop3 => :environment do
                   pop_options  = {:host => ENV['host'],
                                   :port => ENV['port'],
                                   :apop => ENV['apop'],
                                   :username => ENV['username'],
                                   :password => ENV['password'],
                                   :delete_unprocessed => ENV['delete_unprocessed']}
                   options = { :issue => {} }
                   %w(project status tracker category priority).each { |a| options[:issue][a.to_sym] = ENV[a] if ENV[a] }
                   options[:allow_override] = ENV['allow_override'] if ENV['allow_override']
                   options[:unknown_user] = ENV['unknown_user'] if ENV['unknown_user']
                   options[:no_permission_check] = ENV['no_permission_check'] if ENV['no_permission_check']
                   Redmine::POP3.check(pop_options, options)
                 end
                 desc "Send a test email to the user with the provided login name"
                 task :test, [:login] => :environment do |task, args|
                   include Redmine::I18n
                   abort l(:notice_email_error, "Please include the user login to test with. Example: rake redmine:email:test[login]") if args[:login].blank?
                   user = User.find_by_login(args[:login])
                   abort l(:notice_email_error, "User #{args[:login]} not found") unless user && user.logged?
                   ActionMailer::Base.raise_delivery_errors = true
                   begin
                     Mailer.with_synched_deliveries do
-                      Mailer.deliver_test_email(user)
+                      Mailer.test_email(user).deliver
                     end
                     puts l(:notice_email_sent, user.mail)
                   rescue Exception => e
                     abort l(:notice_email_error, e.message)
                   end
                 end
               end
             end

test/unit/lib/redmine/hook_test.rb +2 -2

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../../../test_helper', __FILE__)
             class Redmine::Hook::ManagerTest < ActionView::TestCase
               fixtures :issues
               # Some hooks that are manually registered in these tests
               class TestHook < Redmine::Hook::ViewListener; end
               class TestHook1 < TestHook
                 def view_layouts_base_html_head(context)
                   'Test hook 1 listener.'
                 end
               end
               class TestHook2 < TestHook
                 def view_layouts_base_html_head(context)
                   'Test hook 2 listener.'
                 end
               end
               class TestHook3 < TestHook
                 def view_layouts_base_html_head(context)
                   "Context keys: #{context.keys.collect(&:to_s).sort.join(', ')}."
                 end
               end
               class TestLinkToHook < TestHook
                 def view_layouts_base_html_head(context)
                   link_to('Issues', :controller => 'issues')
                 end
               end
               class TestHookHelperController < ActionController::Base
                 include Redmine::Hook::Helper
               end
               class TestHookHelperView < ActionView::Base
                 include Redmine::Hook::Helper
               end
               Redmine::Hook.clear_listeners
               def setup
                 @hook_module = Redmine::Hook
               end
               def teardown
                 @hook_module.clear_listeners
               end
               def test_clear_listeners
                 assert_equal 0, @hook_module.hook_listeners(:view_layouts_base_html_head).size
                 @hook_module.add_listener(TestHook1)
                 @hook_module.add_listener(TestHook2)
                 assert_equal 2, @hook_module.hook_listeners(:view_layouts_base_html_head).size
                 @hook_module.clear_listeners
                 assert_equal 0, @hook_module.hook_listeners(:view_layouts_base_html_head).size
               end
               def test_add_listener
                 assert_equal 0, @hook_module.hook_listeners(:view_layouts_base_html_head).size
                 @hook_module.add_listener(TestHook1)
                 assert_equal 1, @hook_module.hook_listeners(:view_layouts_base_html_head).size
               end
               def test_call_hook
                 @hook_module.add_listener(TestHook1)
                 assert_equal ['Test hook 1 listener.'], hook_helper.call_hook(:view_layouts_base_html_head)
               end
               def test_call_hook_with_context
                 @hook_module.add_listener(TestHook3)
                 assert_equal ['Context keys: bar, controller, foo, project, request.'],
                              hook_helper.call_hook(:view_layouts_base_html_head, :foo => 1, :bar => 'a')
               end
               def test_call_hook_with_multiple_listeners
                 @hook_module.add_listener(TestHook1)
                 @hook_module.add_listener(TestHook2)
                 assert_equal ['Test hook 1 listener.', 'Test hook 2 listener.'], hook_helper.call_hook(:view_layouts_base_html_head)
               end
               # Context: Redmine::Hook::Helper.call_hook default_url
               def test_call_hook_default_url_options
                 @hook_module.add_listener(TestLinkToHook)
                 assert_equal ['<a href="/issues">Issues</a>'], hook_helper.call_hook(:view_layouts_base_html_head)
               end
               # Context: Redmine::Hook::Helper.call_hook
               def test_call_hook_with_project_added_to_context
                 @hook_module.add_listener(TestHook3)
                 assert_match /project/i, hook_helper.call_hook(:view_layouts_base_html_head)[0]
               end
               def test_call_hook_from_controller_with_controller_added_to_context
                 @hook_module.add_listener(TestHook3)
                 assert_match /controller/i, hook_helper.call_hook(:view_layouts_base_html_head)[0]
               end
               def test_call_hook_from_controller_with_request_added_to_context
                 @hook_module.add_listener(TestHook3)
                 assert_match /request/i, hook_helper.call_hook(:view_layouts_base_html_head)[0]
               end
               def test_call_hook_from_view_with_project_added_to_context
                 @hook_module.add_listener(TestHook3)
                 assert_match /project/i, view_hook_helper.call_hook(:view_layouts_base_html_head)
               end
               def test_call_hook_from_view_with_controller_added_to_context
                 @hook_module.add_listener(TestHook3)
                 assert_match /controller/i, view_hook_helper.call_hook(:view_layouts_base_html_head)
               end
               def test_call_hook_from_view_with_request_added_to_context
                 @hook_module.add_listener(TestHook3)
                 assert_match /request/i, view_hook_helper.call_hook(:view_layouts_base_html_head)
               end
               def test_call_hook_from_view_should_join_responses_with_a_space
                 @hook_module.add_listener(TestHook1)
                 @hook_module.add_listener(TestHook2)
                 assert_equal 'Test hook 1 listener. Test hook 2 listener.',
                              view_hook_helper.call_hook(:view_layouts_base_html_head)
               end
               def test_call_hook_should_not_change_the_default_url_for_email_notifications
                 issue = Issue.find(1)
                 ActionMailer::Base.deliveries.clear
-                Mailer.deliver_issue_add(issue)
+                Mailer.issue_add(issue).deliver
                 mail = ActionMailer::Base.deliveries.last
                 @hook_module.add_listener(TestLinkToHook)
                 hook_helper.call_hook(:view_layouts_base_html_head)
                 ActionMailer::Base.deliveries.clear
-                Mailer.deliver_issue_add(issue)
+                Mailer.issue_add(issue).deliver
                 mail2 = ActionMailer::Base.deliveries.last
                 assert_equal mail_body(mail), mail_body(mail2)
               end
               def hook_helper
                 @hook_helper ||= TestHookHelperController.new
               end
               def view_hook_helper
                 @view_hook_helper ||= TestHookHelperView.new(Rails.root.to_s + '/app/views')
               end
             end

test/unit/mailer_test.rb +37 -37

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             class MailerTest < ActiveSupport::TestCase
               include Redmine::I18n
               include ActionDispatch::Assertions::SelectorAssertions
               fixtures :projects, :enabled_modules, :issues, :users, :members,
                        :member_roles, :roles, :documents, :attachments, :news,
                        :tokens, :journals, :journal_details, :changesets,
                        :trackers, :projects_trackers,
                        :issue_statuses, :enumerations, :messages, :boards, :repositories,
                        :wikis, :wiki_pages, :wiki_contents, :wiki_content_versions,
                        :versions,
                        :comments
               def setup
                 ActionMailer::Base.deliveries.clear
                 Setting.host_name = 'mydomain.foo'
                 Setting.protocol = 'http'
                 Setting.plain_text_mail = '0'
               end
               def test_generated_links_in_emails
                 Setting.default_language = 'en'
                 Setting.host_name = 'mydomain.foo'
                 Setting.protocol = 'https'
                 journal = Journal.find(3)
-                assert Mailer.deliver_issue_edit(journal)
+                assert Mailer.issue_edit(journal).deliver
                 mail = last_email
                 assert_not_nil mail
                 assert_select_email do
                   # link to the main ticket
                   assert_select 'a[href=?]',
                                 'https://mydomain.foo/issues/2#change-3',
                                 :text => 'Feature request #2: Add ingredients categories'
                   # link to a referenced ticket
                   assert_select 'a[href=?][title=?]',
                                 'https://mydomain.foo/issues/1',
                                 'Can\'t print recipes (New)',
                                 :text => '#1'
                   # link to a changeset
                   assert_select 'a[href=?][title=?]',
                                 'https://mydomain.foo/projects/ecookbook/repository/revisions/2',
                                 'This commit fixes #1, #2 and references #1 &amp; #3',
                                 :text => 'r2'
                   # link to a description diff
                   assert_select 'a[href=?][title=?]',
                                 'https://mydomain.foo/journals/diff/3?detail_id=4',
                                 'View differences',
                                 :text => 'diff'
                   # link to an attachment
                   assert_select 'a[href=?]',
                                 'https://mydomain.foo/attachments/download/4/source.rb',
                                 :text => 'source.rb'
                 end
               end
               def test_generated_links_with_prefix
                 Setting.default_language = 'en'
                 relative_url_root = Redmine::Utils.relative_url_root
                 Setting.host_name = 'mydomain.foo/rdm'
                 Setting.protocol = 'http'
                 journal = Journal.find(3)
-                assert Mailer.deliver_issue_edit(journal)
+                assert Mailer.issue_edit(journal).deliver
                 mail = last_email
                 assert_not_nil mail
                 assert_select_email do
                   # link to the main ticket
                   assert_select 'a[href=?]',
                                 'http://mydomain.foo/rdm/issues/2#change-3',
                                 :text => 'Feature request #2: Add ingredients categories'
                   # link to a referenced ticket
                   assert_select 'a[href=?][title=?]',
                                 'http://mydomain.foo/rdm/issues/1',
                                 'Can\'t print recipes (New)',
                                 :text => '#1'
                   # link to a changeset
                   assert_select 'a[href=?][title=?]',
                                 'http://mydomain.foo/rdm/projects/ecookbook/repository/revisions/2',
                                 'This commit fixes #1, #2 and references #1 &amp; #3',
                                 :text => 'r2'
                   # link to a description diff
                   assert_select 'a[href=?][title=?]',
                                 'http://mydomain.foo/rdm/journals/diff/3?detail_id=4',
                                 'View differences',
                                 :text => 'diff'
                   # link to an attachment
                   assert_select 'a[href=?]',
                                 'http://mydomain.foo/rdm/attachments/download/4/source.rb',
                                 :text => 'source.rb'
                 end
               end
               def test_generated_links_with_prefix_and_no_relative_url_root
                 Setting.default_language = 'en'
                 relative_url_root = Redmine::Utils.relative_url_root
                 Setting.host_name = 'mydomain.foo/rdm'
                 Setting.protocol = 'http'
                 Redmine::Utils.relative_url_root = nil
                 journal = Journal.find(3)
-                assert Mailer.deliver_issue_edit(journal)
+                assert Mailer.issue_edit(journal).deliver
                 mail = last_email
                 assert_not_nil mail
                 assert_select_email do
                   # link to the main ticket
                   assert_select 'a[href=?]',
                                 'http://mydomain.foo/rdm/issues/2#change-3',
                                 :text => 'Feature request #2: Add ingredients categories'
                   # link to a referenced ticket
                   assert_select 'a[href=?][title=?]',
                                 'http://mydomain.foo/rdm/issues/1',
                                 'Can\'t print recipes (New)',
                                 :text => '#1'
                   # link to a changeset
                   assert_select 'a[href=?][title=?]',
                                 'http://mydomain.foo/rdm/projects/ecookbook/repository/revisions/2',
                                 'This commit fixes #1, #2 and references #1 &amp; #3',
                                 :text => 'r2'
                   # link to a description diff
                   assert_select 'a[href=?][title=?]',
                                 'http://mydomain.foo/rdm/journals/diff/3?detail_id=4',
                                 'View differences',
                                 :text => 'diff'
                   # link to an attachment
                   assert_select 'a[href=?]',
                                 'http://mydomain.foo/rdm/attachments/download/4/source.rb',
                                 :text => 'source.rb'
                 end
               ensure
                 # restore it
                 Redmine::Utils.relative_url_root = relative_url_root
               end
               def test_email_headers
                 issue = Issue.find(1)
-                Mailer.deliver_issue_add(issue)
+                Mailer.issue_add(issue).deliver
                 mail = last_email
                 assert_not_nil mail
                 assert_equal 'OOF', mail.header['X-Auto-Response-Suppress'].to_s
                 assert_equal 'auto-generated', mail.header['Auto-Submitted'].to_s
               end
               def test_email_headers_should_include_sender
                 issue = Issue.find(1)
-                Mailer.deliver_issue_add(issue)
+                Mailer.issue_add(issue).deliver
                 mail = last_email
                 assert_equal issue.author.login, mail.header['X-Redmine-Sender'].to_s
               end
               def test_plain_text_mail
                 Setting.plain_text_mail = 1
                 journal = Journal.find(2)
-                Mailer.deliver_issue_edit(journal)
+                Mailer.issue_edit(journal).deliver
                 mail = last_email
                 assert_equal "text/plain; charset=UTF-8", mail.content_type
                 assert_equal 0, mail.parts.size
                 assert !mail.encoded.include?('href')
               end
               def test_html_mail
                 Setting.plain_text_mail = 0
                 journal = Journal.find(2)
-                Mailer.deliver_issue_edit(journal)
+                Mailer.issue_edit(journal).deliver
                 mail = last_email
                 assert_equal 2, mail.parts.size
                 assert mail.encoded.include?('href')
               end
               def test_from_header
                 with_settings :mail_from => 'redmine@example.net' do
-                  Mailer.deliver_test_email(User.find(1))
+                  Mailer.test_email(User.find(1)).deliver
                 end
                 mail = last_email
                 assert_equal 'redmine@example.net', mail.from_addrs.first
               end
               def test_from_header_with_phrase
                 with_settings :mail_from => 'Redmine app <redmine@example.net>' do
-                  Mailer.deliver_test_email(User.find(1))
+                  Mailer.test_email(User.find(1)).deliver
                 end
                 mail = last_email
                 assert_equal 'redmine@example.net', mail.from_addrs.first
                 assert_equal 'Redmine app <redmine@example.net>', mail.header['From'].to_s
               end
               def test_should_not_send_email_without_recipient
                 news = News.find(:first)
                 user = news.author
                 # Remove members except news author
                 news.project.memberships.each {|m| m.destroy unless m.user == user}
                 user.pref[:no_self_notified] = false
                 user.pref.save
                 User.current = user
-                Mailer.deliver_news_added(news.reload)
+                Mailer.news_added(news.reload).deliver
                 assert_equal 1, last_email.bcc.size
                 # nobody to notify
                 user.pref[:no_self_notified] = true
                 user.pref.save
                 User.current = user
                 ActionMailer::Base.deliveries.clear
-                Mailer.deliver_news_added(news.reload)
+                Mailer.news_added(news.reload).deliver
                 assert ActionMailer::Base.deliveries.empty?
               end
               def test_issue_add_message_id
                 issue = Issue.find(1)
-                Mailer.deliver_issue_add(issue)
+                Mailer.issue_add(issue).deliver
                 mail = last_email
                 assert_equal Mailer.message_id_for(issue), mail.message_id
                 assert_nil mail.references
               end
               def test_issue_edit_message_id
                 journal = Journal.find(1)
-                Mailer.deliver_issue_edit(journal)
+                Mailer.issue_edit(journal).deliver
                 mail = last_email
                 assert_equal Mailer.message_id_for(journal), mail.message_id
                 assert_include Mailer.message_id_for(journal.issue), mail.references
                 assert_select_email do
                   # link to the update
                   assert_select "a[href=?]",
                                 "http://mydomain.foo/issues/#{journal.journalized_id}#change-#{journal.id}"
                 end
               end
               def test_message_posted_message_id
                 message = Message.find(1)
-                Mailer.deliver_message_posted(message)
+                Mailer.message_posted(message).deliver
                 mail = last_email
                 assert_equal Mailer.message_id_for(message), mail.message_id
                 assert_nil mail.references
                 assert_select_email do
                   # link to the message
                   assert_select "a[href=?]",
                                 "http://mydomain.foo/boards/#{message.board.id}/topics/#{message.id}",
                                 :text => message.subject
                 end
               end
               def test_reply_posted_message_id
                 message = Message.find(3)
-                Mailer.deliver_message_posted(message)
+                Mailer.message_posted(message).deliver
                 mail = last_email
                 assert_equal Mailer.message_id_for(message), mail.message_id
                 assert_include Mailer.message_id_for(message.parent), mail.references
                 assert_select_email do
                   # link to the reply
                   assert_select "a[href=?]",
                                 "http://mydomain.foo/boards/#{message.board.id}/topics/#{message.root.id}?r=#{message.id}#message-#{message.id}",
                                 :text => message.subject
                 end
               end
               context("#issue_add") do
                 setup do
                   ActionMailer::Base.deliveries.clear
                   Setting.bcc_recipients = '1'
                   @issue = Issue.find(1)
                 end
                 should "notify project members" do
-                  assert Mailer.deliver_issue_add(@issue)
+                  assert Mailer.issue_add(@issue).deliver
                   assert last_email.bcc.include?('dlopper@somenet.foo')
                 end
                 should "not notify project members that are not allow to view the issue" do
                   Role.find(2).remove_permission!(:view_issues)
-                  assert Mailer.deliver_issue_add(@issue)
+                  assert Mailer.issue_add(@issue).deliver
                   assert !last_email.bcc.include?('dlopper@somenet.foo')
                 end
                 should "notify issue watchers" do
                   user = User.find(9)
                   # minimal email notification options
                   user.pref[:no_self_notified] = '1'
                   user.pref.save
                   user.mail_notification = false
                   user.save
                   Watcher.create!(:watchable => @issue, :user => user)
-                  assert Mailer.deliver_issue_add(@issue)
+                  assert Mailer.issue_add(@issue).deliver
                   assert last_email.bcc.include?(user.mail)
                 end
                 should "not notify watchers not allowed to view the issue" do
                   user = User.find(9)
                   Watcher.create!(:watchable => @issue, :user => user)
                   Role.non_member.remove_permission!(:view_issues)
-                  assert Mailer.deliver_issue_add(@issue)
+                  assert Mailer.issue_add(@issue).deliver
                   assert !last_email.bcc.include?(user.mail)
                 end
               end
               # test mailer methods for each language
               def test_issue_add
                 issue = Issue.find(1)
                 valid_languages.each do |lang|
                   Setting.default_language = lang.to_s
-                  assert Mailer.deliver_issue_add(issue)
+                  assert Mailer.issue_add(issue).deliver
                 end
               end
               def test_issue_edit
                 journal = Journal.find(1)
                 valid_languages.each do |lang|
                   Setting.default_language = lang.to_s
-                  assert Mailer.deliver_issue_edit(journal)
+                  assert Mailer.issue_edit(journal).deliver
                 end
               end
               def test_document_added
                 document = Document.find(1)
                 valid_languages.each do |lang|
                   Setting.default_language = lang.to_s
-                  assert Mailer.deliver_document_added(document)
+                  assert Mailer.document_added(document).deliver
                 end
               end
               def test_attachments_added
                 attachements = [ Attachment.find_by_container_type('Document') ]
                 valid_languages.each do |lang|
                   Setting.default_language = lang.to_s
-                  assert Mailer.deliver_attachments_added(attachements)
+                  assert Mailer.attachments_added(attachements).deliver
                 end
               end
               def test_version_file_added
                 attachements = [ Attachment.find_by_container_type('Version') ]
-                assert Mailer.deliver_attachments_added(attachements)
+                assert Mailer.attachments_added(attachements).deliver
                 assert_not_nil last_email.bcc
                 assert last_email.bcc.any?
                 assert_select_email do
                   assert_select "a[href=?]", "http://mydomain.foo/projects/ecookbook/files"
                 end
               end
               def test_project_file_added
                 attachements = [ Attachment.find_by_container_type('Project') ]
-                assert Mailer.deliver_attachments_added(attachements)
+                assert Mailer.attachments_added(attachements).deliver
                 assert_not_nil last_email.bcc
                 assert last_email.bcc.any?
                 assert_select_email do
                   assert_select "a[href=?]", "http://mydomain.foo/projects/ecookbook/files"
                 end
               end
               def test_news_added
                 news = News.find(:first)
                 valid_languages.each do |lang|
                   Setting.default_language = lang.to_s
-                  assert Mailer.deliver_news_added(news)
+                  assert Mailer.news_added(news).deliver
                 end
               end
               def test_news_comment_added
                 comment = Comment.find(2)
                 valid_languages.each do |lang|
                   Setting.default_language = lang.to_s
-                  assert Mailer.deliver_news_comment_added(comment)
+                  assert Mailer.news_comment_added(comment).deliver
                 end
               end
               def test_message_posted
                 message = Message.find(:first)
                 recipients = ([message.root] + message.root.children).collect {|m| m.author.mail if m.author}
                 recipients = recipients.compact.uniq
                 valid_languages.each do |lang|
                   Setting.default_language = lang.to_s
-                  assert Mailer.deliver_message_posted(message)
+                  assert Mailer.message_posted(message).deliver
                 end
               end
               def test_wiki_content_added
                 content = WikiContent.find(1)
                 valid_languages.each do |lang|
                   Setting.default_language = lang.to_s
                   assert_difference 'ActionMailer::Base.deliveries.size' do
-                    assert Mailer.deliver_wiki_content_added(content)
+                    assert Mailer.wiki_content_added(content).deliver
                   end
                 end
               end
               def test_wiki_content_updated
                 content = WikiContent.find(1)
                 valid_languages.each do |lang|
                   Setting.default_language = lang.to_s
                   assert_difference 'ActionMailer::Base.deliveries.size' do
-                    assert Mailer.deliver_wiki_content_updated(content)
+                    assert Mailer.wiki_content_updated(content).deliver
                   end
                 end
               end
               def test_account_information
                 user = User.find(2)
                 valid_languages.each do |lang|
                   user.update_attribute :language, lang.to_s
                   user.reload
-                  assert Mailer.deliver_account_information(user, 'pAsswORd')
+                  assert Mailer.account_information(user, 'pAsswORd').deliver
                 end
               end
               def test_lost_password
                 token = Token.find(2)
                 valid_languages.each do |lang|
                   token.user.update_attribute :language, lang.to_s
                   token.reload
-                  assert Mailer.deliver_lost_password(token)
+                  assert Mailer.lost_password(token).deliver
                 end
               end
               def test_register
                 token = Token.find(1)
                 Setting.host_name = 'redmine.foo'
                 Setting.protocol = 'https'
                 valid_languages.each do |lang|
                   token.user.update_attribute :language, lang.to_s
                   token.reload
                   ActionMailer::Base.deliveries.clear
-                  assert Mailer.deliver_register(token)
+                  assert Mailer.register(token).deliver
                   mail = last_email
                   assert_select_email do
                     assert_select "a[href=?]",
                                   "https://redmine.foo/account/activate?token=#{token.value}",
                                   :text => "https://redmine.foo/account/activate?token=#{token.value}"
                   end
                 end
               end
               def test_test
                 user = User.find(1)
                 valid_languages.each do |lang|
                   user.update_attribute :language, lang.to_s
-                  assert Mailer.deliver_test_email(user)
+                  assert Mailer.test_email(user).deliver
                 end
               end
               def test_reminders
                 Mailer.reminders(:days => 42)
                 assert_equal 1, ActionMailer::Base.deliveries.size
                 mail = last_email
                 assert mail.bcc.include?('dlopper@somenet.foo')
                 assert_mail_body_match 'Bug #3: Error 281 when updating a recipe', mail
                 assert_equal '1 issue(s) due in the next 42 days', mail.subject
               end
               def test_reminders_should_not_include_closed_issues
                 with_settings :default_language => 'en' do
                   Issue.create!(:project_id => 1, :tracker_id => 1, :status_id => 5,
                                   :subject => 'Closed issue', :assigned_to_id => 3,
                                   :due_date => 5.days.from_now,
                                   :author_id => 2)
                   ActionMailer::Base.deliveries.clear
                   Mailer.reminders(:days => 42)
                   assert_equal 1, ActionMailer::Base.deliveries.size
                   mail = last_email
                   assert mail.bcc.include?('dlopper@somenet.foo')
                   assert_mail_body_no_match 'Closed issue', mail
                 end
               end
               def test_reminders_for_users
                 Mailer.reminders(:days => 42, :users => ['5'])
                 assert_equal 0, ActionMailer::Base.deliveries.size # No mail for dlopper
                 Mailer.reminders(:days => 42, :users => ['3'])
                 assert_equal 1, ActionMailer::Base.deliveries.size # No mail for dlopper
                 mail = last_email
                 assert mail.bcc.include?('dlopper@somenet.foo')
                 assert_mail_body_match 'Bug #3: Error 281 when updating a recipe', mail
               end
               def test_mailer_should_not_change_locale
                 Setting.default_language = 'en'
                 # Set current language to italian
                 set_language_if_valid 'it'
                 # Send an email to a french user
                 user = User.find(1)
                 user.language = 'fr'
-                Mailer.deliver_account_activated(user)
+                Mailer.account_activated(user).deliver
                 mail = last_email
                 assert_mail_body_match 'Votre compte', mail
                 assert_equal :it, current_language
               end
               def test_with_deliveries_off
                 Mailer.with_deliveries false do
-                  Mailer.deliver_test_email(User.find(1))
+                  Mailer.test_email(User.find(1)).deliver
                 end
                 assert ActionMailer::Base.deliveries.empty?
                 # should restore perform_deliveries
                 assert ActionMailer::Base.perform_deliveries
               end
               def test_layout_should_include_the_emails_header
                 with_settings :emails_header => "*Header content*" do
-                  assert Mailer.deliver_test_email(User.find(1))
+                  assert Mailer.test_email(User.find(1)).deliver
                   assert_select_email do
                     assert_select ".header" do
                       assert_select "strong", :text => "Header content"
                     end
                   end
                 end
               end
             private
               def last_email
                 mail = ActionMailer::Base.deliveries.last
                 assert_not_nil mail
                 mail
               end
             end

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages