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