jro_apps/redmine Commit - r14692:6bb1ea8ae8a1

Use regular edit/update actions and named routes for JournalsController....

Jean-Philippe Lang -

r14692:6bb1ea8ae8a1

parent child

Context file:

r14692:6bb1ea8ae8a1

Collapse all files

app/controllers/journals_controller.rb +16 -15

             # Redmine - project management software
             # Copyright (C) 2006-2015  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 JournalsController < ApplicationController
-              before_filter :find_journal, :only => [:edit, :diff]
+              before_filter :find_journal, :only => [:edit, :update, :diff]
               before_filter :find_issue, :only => [:new]
               before_filter :find_optional_project, :only => [:index]
-              before_filter :authorize, :only => [:new, :edit, :diff]
+              before_filter :authorize, :only => [:new, :edit, :update, :diff]
               accept_rss_auth :index
               menu_item :issues
               helper :issues
               helper :custom_fields
               helper :queries
               include QueriesHelper
               helper :sort
               include SortHelper
               def index
                 retrieve_query
                 sort_init 'id', 'desc'
                 sort_update(@query.sortable_columns)
                 if @query.valid?
                   @journals = @query.journals(:order => "#{Journal.table_name}.created_on DESC",
                                               :limit => 25)
                 end
                 @title = (@project ? @project.name : Setting.app_title) + ": " + (@query.new_record? ? l(:label_changes_details) : @query.name)
                 render :layout => false, :content_type => 'application/atom+xml'
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def diff
                 @issue = @journal.issue
                 if params[:detail_id].present?
                   @detail = @journal.details.find_by_id(params[:detail_id])
                 else
                   @detail = @journal.details.detect {|d| d.property == 'attr' && d.prop_key == 'description'}
                 end
                 unless @issue && @detail
                   render_404
                   return false
                 end
                 if @detail.property == 'cf'
                   unless @detail.custom_field && @detail.custom_field.visible_by?(@issue.project, User.current)
                     raise ::Unauthorized
                   end
                 end
                 @diff = Redmine::Helpers::Diff.new(@detail.value, @detail.old_value)
               end
               def new
                 @journal = Journal.visible.find(params[:journal_id]) if params[:journal_id]
                 if @journal
                   user = @journal.user
                   text = @journal.notes
                 else
                   user = @issue.author
                   text = @issue.description
                 end
                 # Replaces pre blocks with [...]
                 text = text.to_s.strip.gsub(%r{<pre>(.*?)</pre>}m, '[...]')
                 @content = "#{ll(Setting.default_language, :text_user_wrote, user)}\n> "
                 @content << text.gsub(/(\r?\n|\r\n?)/, "\n> ") + "\n\n"
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
               def edit
                 (render_403; return false) unless @journal.editable_by?(User.current)
-                if request.post?
+                respond_to do |format|
-                  @journal.update_attributes(:notes => params[:notes]) if params[:notes]
+                  # TODO: implement non-JS journal update
-                  @journal.destroy if @journal.details.empty? && @journal.notes.blank?
+                  format.js
-                  call_hook(:controller_journals_edit_post, { :journal => @journal, :params => params})
+                end
-                  respond_to do |format|
+              end
-                    format.html { redirect_to issue_path(@journal.journalized) }
-                    format.js { render :action => 'update' }
+              def update
-                  end
+                (render_403; return false) unless @journal.editable_by?(User.current)
-                else
+                @journal.update_attributes(:notes => params[:notes]) if params[:notes]
-                  respond_to do |format|
+                @journal.destroy if @journal.details.empty? && @journal.notes.blank?
-                    # TODO: implement non-JS journal update
+                call_hook(:controller_journals_edit_post, { :journal => @journal, :params => params})
-                    format.js
+                respond_to do |format|
-                  end
+                  format.html { redirect_to issue_path(@journal.journalized) }
+                  format.js
                 end
               end
               private
               def find_journal
                 @journal = Journal.visible.find(params[:id])
                 @project = @journal.journalized.project
               rescue ActiveRecord::RecordNotFound
                 render_404
               end
             end

app/helpers/issues_helper.rb +1 -2

             # encoding: utf-8
             #
             # Redmine - project management software
             # Copyright (C) 2006-2015  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.
             module IssuesHelper
               include ApplicationHelper
               include Redmine::Export::PDF::IssuesPdfHelper
               def issue_list(issues, &block)
                 ancestors = []
                 issues.each do |issue|
                   while (ancestors.any? && !issue.is_descendant_of?(ancestors.last))
                     ancestors.pop
                   end
                   yield issue, ancestors.size
                   ancestors << issue unless issue.leaf?
                 end
               end
               def grouped_issue_list(issues, query, issue_count_by_group, &block)
                 previous_group, first = false, true
                 totals_by_group = query.totalable_columns.inject({}) do |h, column|
                   h[column] = query.total_by_group_for(column)
                   h
                 end
                 issue_list(issues) do |issue, level|
                   group_name = group_count = nil
                   if query.grouped?
                     group = query.group_by_column.value(issue)
                     if first || group != previous_group
                       if group.blank? && group != false
                         group_name = "(#{l(:label_blank_value)})"
                       else
                         group_name = format_object(group)
                       end
                       group_name ||= ""
                       group_count = issue_count_by_group[group]
                       group_totals = totals_by_group.map {|column, t| total_tag(column, t[group] || 0)}.join(" ").html_safe
                     end
                   end
                   yield issue, level, group_name, group_count, group_totals
                   previous_group, first = group, false
                 end
               end
               # Renders a HTML/CSS tooltip
               #
               # To use, a trigger div is needed.  This is a div with the class of "tooltip"
               # that contains this method wrapped in a span with the class of "tip"
               #
               #    <div class="tooltip"><%= link_to_issue(issue) %>
               #      <span class="tip"><%= render_issue_tooltip(issue) %></span>
               #    </div>
               #
               def render_issue_tooltip(issue)
                 @cached_label_status ||= l(:field_status)
                 @cached_label_start_date ||= l(:field_start_date)
                 @cached_label_due_date ||= l(:field_due_date)
                 @cached_label_assigned_to ||= l(:field_assigned_to)
                 @cached_label_priority ||= l(:field_priority)
                 @cached_label_project ||= l(:field_project)
                 link_to_issue(issue) + "<br /><br />".html_safe +
                   "<strong>#{@cached_label_project}</strong>: #{link_to_project(issue.project)}<br />".html_safe +
                   "<strong>#{@cached_label_status}</strong>: #{h(issue.status.name)}<br />".html_safe +
                   "<strong>#{@cached_label_start_date}</strong>: #{format_date(issue.start_date)}<br />".html_safe +
                   "<strong>#{@cached_label_due_date}</strong>: #{format_date(issue.due_date)}<br />".html_safe +
                   "<strong>#{@cached_label_assigned_to}</strong>: #{h(issue.assigned_to)}<br />".html_safe +
                   "<strong>#{@cached_label_priority}</strong>: #{h(issue.priority.name)}".html_safe
               end
               def issue_heading(issue)
                 h("#{issue.tracker} ##{issue.id}")
               end
               def render_issue_subject_with_tree(issue)
                 s = ''
                 ancestors = issue.root? ? [] : issue.ancestors.visible.to_a
                 ancestors.each do |ancestor|
                   s << '<div>' + content_tag('p', link_to_issue(ancestor, :project => (issue.project_id != ancestor.project_id)))
                 end
                 s << '<div>'
                 subject = h(issue.subject)
                 if issue.is_private?
                   subject = content_tag('span', l(:field_is_private), :class => 'private') + ' ' + subject
                 end
                 s << content_tag('h3', subject)
                 s << '</div>' * (ancestors.size + 1)
                 s.html_safe
               end
               def render_descendants_tree(issue)
                 s = '<form><table class="list issues">'
                 issue_list(issue.descendants.visible.preload(:status, :priority, :tracker).sort_by(&:lft)) do |child, level|
                   css = "issue issue-#{child.id} hascontextmenu #{issue.css_classes}"
                   css << " idnt idnt-#{level}" if level > 0
                   s << content_tag('tr',
                          content_tag('td', check_box_tag("ids[]", child.id, false, :id => nil), :class => 'checkbox') +
                          content_tag('td', link_to_issue(child, :project => (issue.project_id != child.project_id)), :class => 'subject', :style => 'width: 50%') +
                          content_tag('td', h(child.status)) +
                          content_tag('td', link_to_user(child.assigned_to)) +
                          content_tag('td', progress_bar(child.done_ratio)),
                          :class => css)
                 end
                 s << '</table></form>'
                 s.html_safe
               end
               def issue_estimated_hours_details(issue)
                 if issue.total_estimated_hours.present?
                   if issue.total_estimated_hours == issue.estimated_hours
                     l_hours_short(issue.estimated_hours)
                   else
                     s = issue.estimated_hours.present? ? l_hours_short(issue.estimated_hours) : ""
                     s << " (#{l(:label_total)}: #{l_hours_short(issue.total_estimated_hours)})"
                     s.html_safe
                   end
                 end
               end
               def issue_spent_hours_details(issue)
                 if issue.total_spent_hours > 0
                   if issue.total_spent_hours == issue.spent_hours
                     link_to(l_hours_short(issue.spent_hours), issue_time_entries_path(issue))
                   else
                     s = issue.spent_hours > 0 ? l_hours_short(issue.spent_hours) : ""
                     s << " (#{l(:label_total)}: #{link_to l_hours_short(issue.total_spent_hours), issue_time_entries_path(issue)})"
                     s.html_safe
                   end
                 end
               end
               # Returns an array of error messages for bulk edited issues
               def bulk_edit_error_messages(issues)
                 messages = {}
                 issues.each do |issue|
                   issue.errors.full_messages.each do |message|
                     messages[message] ||= []
                     messages[message] << issue
                   end
                 end
                 messages.map { |message, issues|
                   "#{message}: " + issues.map {|i| "##{i.id}"}.join(', ')
                 }
              end
               # Returns a link for adding a new subtask to the given issue
               def link_to_new_subtask(issue)
                 attrs = {
                   :tracker_id => issue.tracker,
                   :parent_issue_id => issue
                 }
                 link_to(l(:button_add), new_project_issue_path(issue.project, :issue => attrs))
               end
               class IssueFieldsRows
                 include ActionView::Helpers::TagHelper
                 def initialize
                   @left = []
                   @right = []
                 end
                 def left(*args)
                   args.any? ? @left << cells(*args) : @left
                 end
                 def right(*args)
                   args.any? ? @right << cells(*args) : @right
                 end
                 def size
                   @left.size > @right.size ? @left.size : @right.size
                 end
                 def to_html
                   content =
                     content_tag('div', @left.reduce(&:+), :class => 'splitcontentleft') +
                     content_tag('div', @right.reduce(&:+), :class => 'splitcontentleft')
                   content_tag('div', content, :class => 'splitcontent')
                 end
                 def cells(label, text, options={})
                   options[:class] = [options[:class] || "", 'attribute'].join(' ')
                   content_tag 'div',
                     content_tag('div', label + ":", :class => 'label') + content_tag('div', text, :class => 'value'),
                     options
                 end
               end
               def issue_fields_rows
                 r = IssueFieldsRows.new
                 yield r
                 r.to_html
               end
               def render_custom_fields_rows(issue)
                 values = issue.visible_custom_field_values
                 return if values.empty?
                 half = (values.size / 2.0).ceil
                 issue_fields_rows do |rows|
                   values.each_with_index do |value, i|
                     css = "cf_#{value.custom_field.id}"
                     m = (i < half ? :left : :right)
                     rows.send m, custom_field_name_tag(value.custom_field), show_value(value), :class => css
                   end
                 end
               end
               # Returns the path for updating the issue form
               # with project as the current project
               def update_issue_form_path(project, issue)
                 options = {:format => 'js'}
                 if issue.new_record?
                   if project
                     new_project_issue_path(project, options)
                   else
                     new_issue_path(options)
                   end
                 else
                   edit_issue_path(issue, options)
                 end
               end
               # Returns the number of descendants for an array of issues
               def issues_descendant_count(issues)
                 ids = issues.reject(&:leaf?).map {|issue| issue.descendants.ids}.flatten.uniq
                 ids -= issues.map(&:id)
                 ids.size
               end
               def issues_destroy_confirmation_message(issues)
                 issues = [issues] unless issues.is_a?(Array)
                 message = l(:text_issues_destroy_confirmation)
                 descendant_count = issues_descendant_count(issues)
                 if descendant_count > 0
                   message << "\n" + l(:text_issues_destroy_descendants_confirmation, :count => descendant_count)
                 end
                 message
               end
               # Returns an array of users that are proposed as watchers
               # on the new issue form
               def users_for_new_issue_watchers(issue)
                 users = issue.watcher_users
                 if issue.project.users.count <= 20
                   users = (users + issue.project.users.sort).uniq
                 end
                 users
               end
               def sidebar_queries
                 unless @sidebar_queries
                   @sidebar_queries = IssueQuery.visible.
                     order("#{Query.table_name}.name ASC").
                     # Project specific queries and global queries
                     where(@project.nil? ? ["project_id IS NULL"] : ["project_id IS NULL OR project_id = ?", @project.id]).
                     to_a
                 end
                 @sidebar_queries
               end
               def query_links(title, queries)
                 return '' if queries.empty?
                 # links to #index on issues/show
                 url_params = controller_name == 'issues' ? {:controller => 'issues', :action => 'index', :project_id => @project} : params
                 content_tag('h3', title) + "\n" +
                   content_tag('ul',
                     queries.collect {|query|
                         css = 'query'
                         css << ' selected' if query == @query
                         content_tag('li', link_to(query.name, url_params.merge(:query_id => query), :class => css))
                       }.join("\n").html_safe,
                     :class => 'queries'
                   ) + "\n"
               end
               def render_sidebar_queries
                 out = ''.html_safe
                 out << query_links(l(:label_my_queries), sidebar_queries.select(&:is_private?))
                 out << query_links(l(:label_query_plural), sidebar_queries.reject(&:is_private?))
                 out
               end
               def email_issue_attributes(issue, user)
                 items = []
                 %w(author status priority assigned_to category fixed_version).each do |attribute|
                   unless issue.disabled_core_fields.include?(attribute+"_id")
                     items << "#{l("field_#{attribute}")}: #{issue.send attribute}"
                   end
                 end
                 issue.visible_custom_field_values(user).each do |value|
                   items << "#{value.custom_field.name}: #{show_value(value, false)}"
                 end
                 items
               end
               def render_email_issue_attributes(issue, user, html=false)
                 items = email_issue_attributes(issue, user)
                 if html
                   content_tag('ul', items.map{|s| content_tag('li', s)}.join("\n").html_safe)
                 else
                   items.map{|s| "* #{s}"}.join("\n")
                 end
               end
               # Returns the textual representation of a journal details
               # as an array of strings
               def details_to_strings(details, no_html=false, options={})
                 options[:only_path] = (options[:only_path] == false ? false : true)
                 strings = []
                 values_by_field = {}
                 details.each do |detail|
                   if detail.property == 'cf'
                     field = detail.custom_field
                     if field && field.multiple?
                       values_by_field[field] ||= {:added => [], :deleted => []}
                       if detail.old_value
                         values_by_field[field][:deleted] << detail.old_value
                       end
                       if detail.value
                         values_by_field[field][:added] << detail.value
                       end
                       next
                     end
                   end
                   strings << show_detail(detail, no_html, options)
                 end
                 if values_by_field.present?
                   multiple_values_detail = Struct.new(:property, :prop_key, :custom_field, :old_value, :value)
                   values_by_field.each do |field, changes|
                     if changes[:added].any?
                       detail = multiple_values_detail.new('cf', field.id.to_s, field)
                       detail.value = changes[:added]
                       strings << show_detail(detail, no_html, options)
                     end
                     if changes[:deleted].any?
                       detail = multiple_values_detail.new('cf', field.id.to_s, field)
                       detail.old_value = changes[:deleted]
                       strings << show_detail(detail, no_html, options)
                     end
                   end
                 end
                 strings
               end
               # Returns the textual representation of a single journal detail
               def show_detail(detail, no_html=false, options={})
                 multiple = false
                 show_diff = false
                 case detail.property
                 when 'attr'
                   field = detail.prop_key.to_s.gsub(/\_id$/, "")
                   label = l(("field_" + field).to_sym)
                   case detail.prop_key
                   when 'due_date', 'start_date'
                     value = format_date(detail.value.to_date) if detail.value
                     old_value = format_date(detail.old_value.to_date) if detail.old_value
                   when 'project_id', 'status_id', 'tracker_id', 'assigned_to_id',
                         'priority_id', 'category_id', 'fixed_version_id'
                     value = find_name_by_reflection(field, detail.value)
                     old_value = find_name_by_reflection(field, detail.old_value)
                   when 'estimated_hours'
                     value = "%0.02f" % detail.value.to_f unless detail.value.blank?
                     old_value = "%0.02f" % detail.old_value.to_f unless detail.old_value.blank?
                   when 'parent_id'
                     label = l(:field_parent_issue)
                     value = "##{detail.value}" unless detail.value.blank?
                     old_value = "##{detail.old_value}" unless detail.old_value.blank?
                   when 'is_private'
                     value = l(detail.value == "0" ? :general_text_No : :general_text_Yes) unless detail.value.blank?
                     old_value = l(detail.old_value == "0" ? :general_text_No : :general_text_Yes) unless detail.old_value.blank?
                   when 'description'
                     show_diff = true
                   end
                 when 'cf'
                   custom_field = detail.custom_field
                   if custom_field
                     label = custom_field.name
                     if custom_field.format.class.change_as_diff
                       show_diff = true
                     else
                       multiple = custom_field.multiple?
                       value = format_value(detail.value, custom_field) if detail.value
                       old_value = format_value(detail.old_value, custom_field) if detail.old_value
                     end
                   end
                 when 'attachment'
                   label = l(:label_attachment)
                 when 'relation'
                   if detail.value && !detail.old_value
                     rel_issue = Issue.visible.find_by_id(detail.value)
                     value = rel_issue.nil? ? "#{l(:label_issue)} ##{detail.value}" :
                               (no_html ? rel_issue : link_to_issue(rel_issue, :only_path => options[:only_path]))
                   elsif detail.old_value && !detail.value
                     rel_issue = Issue.visible.find_by_id(detail.old_value)
                     old_value = rel_issue.nil? ? "#{l(:label_issue)} ##{detail.old_value}" :
                                       (no_html ? rel_issue : link_to_issue(rel_issue, :only_path => options[:only_path]))
                   end
                   relation_type = IssueRelation::TYPES[detail.prop_key]
                   label = l(relation_type[:name]) if relation_type
                 end
                 call_hook(:helper_issues_show_detail_after_setting,
                           {:detail => detail, :label => label, :value => value, :old_value => old_value })
                 label ||= detail.prop_key
                 value ||= detail.value
                 old_value ||= detail.old_value
                 unless no_html
                   label = content_tag('strong', label)
                   old_value = content_tag("i", h(old_value)) if detail.old_value
                   if detail.old_value && detail.value.blank? && detail.property != 'relation'
                     old_value = content_tag("del", old_value)
                   end
                   if detail.property == 'attachment' && value.present? &&
                       atta = detail.journal.journalized.attachments.detect {|a| a.id == detail.prop_key.to_i}
                     # Link to the attachment if it has not been removed
                     value = link_to_attachment(atta, :download => true, :only_path => options[:only_path])
                     if options[:only_path] != false && atta.is_text?
                       value += link_to('',
                                        { :controller => 'attachments', :action => 'show',
                                          :id => atta, :filename => atta.filename },
                                        :class => 'icon icon-magnifier')
                     end
                   else
                     value = content_tag("i", h(value)) if value
                   end
                 end
                 if show_diff
                   s = l(:text_journal_changed_no_detail, :label => label)
                   unless no_html
                     diff_link = link_to 'diff',
-                      {:controller => 'journals', :action => 'diff', :id => detail.journal_id,
+                      diff_journal_url(detail.journal_id, :detail_id => detail.id, :only_path => options[:only_path]),
-                       :detail_id => detail.id, :only_path => options[:only_path]},
                       :title => l(:label_view_diff)
                     s << " (#{ diff_link })"
                   end
                   s.html_safe
                 elsif detail.value.present?
                   case detail.property
                   when 'attr', 'cf'
                     if detail.old_value.present?
                       l(:text_journal_changed, :label => label, :old => old_value, :new => value).html_safe
                     elsif multiple
                       l(:text_journal_added, :label => label, :value => value).html_safe
                     else
                       l(:text_journal_set_to, :label => label, :value => value).html_safe
                     end
                   when 'attachment', 'relation'
                     l(:text_journal_added, :label => label, :value => value).html_safe
                   end
                 else
                   l(:text_journal_deleted, :label => label, :old => old_value).html_safe
                 end
               end
               # Find the name of an associated record stored in the field attribute
               def find_name_by_reflection(field, id)
                 unless id.present?
                   return nil
                 end
                 @detail_value_name_by_reflection ||= Hash.new do |hash, key|
                   association = Issue.reflect_on_association(key.first.to_sym)
                   name = nil
                   if association
                     record = association.klass.find_by_id(key.last)
                     if record
                       name = record.name.force_encoding('UTF-8')
                     end
                   end
                   hash[key] = name
                 end
                 @detail_value_name_by_reflection[[field, id]]
               end
               # Renders issue children recursively
               def render_api_issue_children(issue, api)
                 return if issue.leaf?
                 api.array :children do
                   issue.children.each do |child|
                     api.issue(:id => child.id) do
                       api.tracker(:id => child.tracker_id, :name => child.tracker.name) unless child.tracker.nil?
                       api.subject child.subject
                       render_api_issue_children(child, api)
                     end
                   end
                 end
               end
             end

app/helpers/journals_helper.rb +4 -4

             # encoding: utf-8
             #
             # Redmine - project management software
             # Copyright (C) 2006-2015  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.
             module JournalsHelper
               # Returns the attachments of a journal that are displayed as thumbnails
               def journal_thumbnail_attachments(journal)
                 ids = journal.details.select {|d| d.property == 'attachment' && d.value.present?}.map(&:prop_key)
                 ids.any? ? Attachment.where(:id => ids).select(&:thumbnailable?) : []
               end
               def render_notes(issue, journal, options={})
                 content = ''
                 editable = User.current.logged? && (User.current.allowed_to?(:edit_issue_notes, issue.project) || (journal.user == User.current && User.current.allowed_to?(:edit_own_issue_notes, issue.project)))
                 links = []
                 if !journal.notes.blank?
                   links << link_to('',
-                                   {:controller => 'journals', :action => 'new', :id => issue, :journal_id => journal},
+                                   quoted_issue_path(issue, :journal_id => journal),
                                    :remote => true,
                                    :method => 'post',
                                    :title => l(:button_quote),
                                    :class => 'icon-only icon-comment'
                                   ) if options[:reply_links]
                   links << link_to('',
-                                   {:controller => 'journals', :action => 'edit', :id => journal},
+                                   edit_journal_path(journal),
                                    :remote => true,
                                    :method => 'get',
                                    :title => l(:button_edit),
                                    :class => 'icon-only icon-edit'
                                   ) if editable
                   links << link_to('',
-                                   {:controller => 'journals', :action => 'edit', :id => journal, :notes => ""},
+                                   journal_path(journal, :notes => ""),
                                    :remote => true,
-                                   :method => :post, :data => {:confirm => l(:text_are_you_sure)},
+                                   :method => 'put', :data => {:confirm => l(:text_are_you_sure)},
                                    :title => l(:button_delete),
                                    :class => 'icon-only icon-del'
                                   ) if editable
                 end
                 content << content_tag('div', links.join(' ').html_safe, :class => 'contextual') unless links.empty?
                 content << textilizable(journal, :notes)
                 css_classes = "wiki"
                 css_classes << " editable" if editable
                 content_tag('div', content.html_safe, :id => "journal-#{journal.id}-notes", :class => css_classes)
               end
             end

app/views/journals/_notes_form.html.erb +2 -1

-            <%= form_tag({:controller => 'journals', :action => 'edit', :id => @journal},
+            <%= form_tag(journal_path(@journal),
                          :remote => true,
+                         :method => 'put',
                          :id => "journal-#{@journal.id}-form") do %>
                 <%= label_tag "notes", l(:description_notes), :class => "hidden-for-sighted" %>
                 <%= text_area_tag :notes, @journal.notes,
                       :id => "journal_#{@journal.id}_notes",
                       :class => 'wiki-edit',
                       :rows => (@journal.notes.blank? ? 10 : [[10, @journal.notes.length / 50].max, 100].min) %>
                 <%= call_hook(:view_journals_notes_form_after_notes, { :journal => @journal}) %>
                 <p><%= submit_tag l(:button_save) %>
                 <%= preview_link preview_edit_issue_path(:project_id => @project, :id => @journal.issue),
                                  "journal-#{@journal.id}-form",
                                  "journal_#{@journal.id}_preview" %> |
                 <%= link_to l(:button_cancel), '#', :onclick => "$('#journal-#{@journal.id}-form').remove(); $('#journal-#{@journal.id}-notes').show(); return false;" %></p>
                 <div id="journal_<%= @journal.id %>_preview" class="wiki"></div>
             <% end %>
             <%= wikitoolbar_for "journal_#{@journal.id}_notes" %>

config/routes.rb +5 -2

             # Redmine - project management software
             # Copyright (C) 2006-2015  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.
             Rails.application.routes.draw do
               root :to => 'welcome#index', :as => 'home'
               match 'login', :to => 'account#login', :as => 'signin', :via => [:get, :post]
               match 'logout', :to => 'account#logout', :as => 'signout', :via => [:get, :post]
               match 'account/register', :to => 'account#register', :via => [:get, :post], :as => 'register'
               match 'account/lost_password', :to => 'account#lost_password', :via => [:get, :post], :as => 'lost_password'
               match 'account/activate', :to => 'account#activate', :via => :get
               get 'account/activation_email', :to => 'account#activation_email', :as => 'activation_email'
               match '/news/preview', :controller => 'previews', :action => 'news', :as => 'preview_news', :via => [:get, :post, :put, :patch]
               match '/issues/preview/new/:project_id', :to => 'previews#issue', :as => 'preview_new_issue', :via => [:get, :post, :put, :patch]
               match '/issues/preview/edit/:id', :to => 'previews#issue', :as => 'preview_edit_issue', :via => [:get, :post, :put, :patch]
               match '/issues/preview', :to => 'previews#issue', :as => 'preview_issue', :via => [:get, :post, :put, :patch]
               match 'projects/:id/wiki', :to => 'wikis#edit', :via => :post
               match 'projects/:id/wiki/destroy', :to => 'wikis#destroy', :via => [:get, :post]
               match 'boards/:board_id/topics/new', :to => 'messages#new', :via => [:get, :post], :as => 'new_board_message'
               get 'boards/:board_id/topics/:id', :to => 'messages#show', :as => 'board_message'
               match 'boards/:board_id/topics/quote/:id', :to => 'messages#quote', :via => [:get, :post]
               get 'boards/:board_id/topics/:id/edit', :to => 'messages#edit'
               post 'boards/:board_id/topics/preview', :to => 'messages#preview', :as => 'preview_board_message'
               post 'boards/:board_id/topics/:id/replies', :to => 'messages#reply'
               post 'boards/:board_id/topics/:id/edit', :to => 'messages#edit'
               post 'boards/:board_id/topics/:id/destroy', :to => 'messages#destroy'
               # Misc issue routes. TODO: move into resources
               match '/issues/auto_complete', :to => 'auto_completes#issues', :via => :get, :as => 'auto_complete_issues'
               match '/issues/context_menu', :to => 'context_menus#issues', :as => 'issues_context_menu', :via => [:get, :post]
               match '/issues/changes', :to => 'journals#index', :as => 'issue_changes', :via => :get
               match '/issues/:id/quoted', :to => 'journals#new', :id => /\d+/, :via => :post, :as => 'quoted_issue'
-              match '/journals/diff/:id', :to => 'journals#diff', :id => /\d+/, :via => :get
+              resources :journals, :only => [:edit, :update] do
-              match '/journals/edit/:id', :to => 'journals#edit', :id => /\d+/, :via => [:get, :post]
+                member do
+                  get 'diff'
+                end
+              end
               get '/projects/:project_id/issues/gantt', :to => 'gantts#show', :as => 'project_gantt'
               get '/issues/gantt', :to => 'gantts#show'
               get '/projects/:project_id/issues/calendar', :to => 'calendars#show', :as => 'project_calendar'
               get '/issues/calendar', :to => 'calendars#show'
               get 'projects/:id/issues/report', :to => 'reports#issue_report', :as => 'project_issues_report'
               get 'projects/:id/issues/report/:detail', :to => 'reports#issue_report_details', :as => 'project_issues_report_details'
               get   '/issues/imports/new', :to => 'imports#new', :as => 'new_issues_import'
               post  '/imports', :to => 'imports#create', :as => 'imports'
               get   '/imports/:id', :to => 'imports#show', :as => 'import'
               match '/imports/:id/settings', :to => 'imports#settings', :via => [:get, :post], :as => 'import_settings'
               match '/imports/:id/mapping', :to => 'imports#mapping', :via => [:get, :post], :as => 'import_mapping'
               match '/imports/:id/run', :to => 'imports#run', :via => [:get, :post], :as => 'import_run'
               match 'my/account', :controller => 'my', :action => 'account', :via => [:get, :post]
               match 'my/account/destroy', :controller => 'my', :action => 'destroy', :via => [:get, :post]
               match 'my/page', :controller => 'my', :action => 'page', :via => :get
               match 'my', :controller => 'my', :action => 'index', :via => :get # Redirects to my/page
               get 'my/api_key', :to => 'my#show_api_key', :as => 'my_api_key'
               post 'my/api_key', :to => 'my#reset_api_key'
               post 'my/rss_key', :to => 'my#reset_rss_key', :as => 'my_rss_key'
               match 'my/password', :controller => 'my', :action => 'password', :via => [:get, :post]
               match 'my/page_layout', :controller => 'my', :action => 'page_layout', :via => :get
               match 'my/add_block', :controller => 'my', :action => 'add_block', :via => :post
               match 'my/remove_block', :controller => 'my', :action => 'remove_block', :via => :post
               match 'my/order_blocks', :controller => 'my', :action => 'order_blocks', :via => :post
               resources :users do
                 resources :memberships, :controller => 'principal_memberships'
                 resources :email_addresses, :only => [:index, :create, :update, :destroy]
               end
               post 'watchers/watch', :to => 'watchers#watch', :as => 'watch'
               delete 'watchers/watch', :to => 'watchers#unwatch'
               get 'watchers/new', :to => 'watchers#new'
               post 'watchers', :to => 'watchers#create'
               post 'watchers/append', :to => 'watchers#append'
               delete 'watchers', :to => 'watchers#destroy'
               get 'watchers/autocomplete_for_user', :to => 'watchers#autocomplete_for_user'
               # Specific routes for issue watchers API
               post 'issues/:object_id/watchers', :to => 'watchers#create', :object_type => 'issue'
               delete 'issues/:object_id/watchers/:user_id' => 'watchers#destroy', :object_type => 'issue'
               resources :projects do
                 member do
                   get 'settings(/:tab)', :action => 'settings', :as => 'settings'
                   post 'modules'
                   post 'archive'
                   post 'unarchive'
                   post 'close'
                   post 'reopen'
                   match 'copy', :via => [:get, :post]
                 end
                 shallow do
                   resources :memberships, :controller => 'members', :only => [:index, :show, :new, :create, :update, :destroy] do
                     collection do
                       get 'autocomplete'
                     end
                   end
                 end
                 resource :enumerations, :controller => 'project_enumerations', :only => [:update, :destroy]
                 get 'issues/:copy_from/copy', :to => 'issues#new', :as => 'copy_issue'
                 resources :issues, :only => [:index, :new, :create]
                 # Used when updating the form of a new issue
                 post 'issues/new', :to => 'issues#new'
                 resources :files, :only => [:index, :new, :create]
                 resources :versions, :except => [:index, :show, :edit, :update, :destroy] do
                   collection do
                     put 'close_completed'
                   end
                 end
                 get 'versions.:format', :to => 'versions#index'
                 get 'roadmap', :to => 'versions#index', :format => false
                 get 'versions', :to => 'versions#index'
                 resources :news, :except => [:show, :edit, :update, :destroy]
                 resources :time_entries, :controller => 'timelog', :except => [:show, :edit, :update, :destroy] do
                   get 'report', :on => :collection
                 end
                 resources :queries, :only => [:new, :create]
                 shallow do
                   resources :issue_categories
                 end
                 resources :documents, :except => [:show, :edit, :update, :destroy]
                 resources :boards
                 shallow do
                   resources :repositories, :except => [:index, :show] do
                     member do
                       match 'committers', :via => [:get, :post]
                     end
                   end
                 end
                 match 'wiki/index', :controller => 'wiki', :action => 'index', :via => :get
                 resources :wiki, :except => [:index, :new, :create], :as => 'wiki_page' do
                   member do
                     get 'rename'
                     post 'rename'
                     get 'history'
                     get 'diff'
                     match 'preview', :via => [:post, :put, :patch]
                     post 'protect'
                     post 'add_attachment'
                   end
                   collection do
                     get 'export'
                     get 'date_index'
                   end
                 end
                 match 'wiki', :controller => 'wiki', :action => 'show', :via => :get
                 get 'wiki/:id/:version', :to => 'wiki#show', :constraints => {:version => /\d+/}
                 delete 'wiki/:id/:version', :to => 'wiki#destroy_version'
                 get 'wiki/:id/:version/annotate', :to => 'wiki#annotate'
                 get 'wiki/:id/:version/diff', :to => 'wiki#diff'
               end
               resources :issues do
                 member do
                   # Used when updating the form of an existing issue
                   patch 'edit', :to => 'issues#edit'
                 end
                 collection do
                   match 'bulk_edit', :via => [:get, :post]
                   post 'bulk_update'
                 end
                 resources :time_entries, :controller => 'timelog', :except => [:show, :edit, :update, :destroy] do
                   collection do
                     get 'report'
                   end
                 end
                 shallow do
                   resources :relations, :controller => 'issue_relations', :only => [:index, :show, :create, :destroy]
                 end
               end
               # Used when updating the form of a new issue outside a project
               post '/issues/new', :to => 'issues#new'
               match '/issues', :controller => 'issues', :action => 'destroy', :via => :delete
               resources :queries, :except => [:show]
               resources :news, :only => [:index, :show, :edit, :update, :destroy]
               match '/news/:id/comments', :to => 'comments#create', :via => :post
               match '/news/:id/comments/:comment_id', :to => 'comments#destroy', :via => :delete
               resources :versions, :only => [:show, :edit, :update, :destroy] do
                 post 'status_by', :on => :member
               end
               resources :documents, :only => [:show, :edit, :update, :destroy] do
                 post 'add_attachment', :on => :member
               end
               match '/time_entries/context_menu', :to => 'context_menus#time_entries', :as => :time_entries_context_menu, :via => [:get, :post]
               resources :time_entries, :controller => 'timelog', :except => :destroy do
                 collection do
                   get 'report'
                   get 'bulk_edit'
                   post 'bulk_update'
                 end
               end
               match '/time_entries/:id', :to => 'timelog#destroy', :via => :delete, :id => /\d+/
               # TODO: delete /time_entries for bulk deletion
               match '/time_entries/destroy', :to => 'timelog#destroy', :via => :delete
               # Used to update the new time entry form
               post '/time_entries/new', :to => 'timelog#new'
               get 'projects/:id/activity', :to => 'activities#index', :as => :project_activity
               get 'activity', :to => 'activities#index'
               # repositories routes
               get 'projects/:id/repository/:repository_id/statistics', :to => 'repositories#stats'
               get 'projects/:id/repository/:repository_id/graph', :to => 'repositories#graph'
               get 'projects/:id/repository/:repository_id/changes(/*path)',
                   :to => 'repositories#changes',
                   :format => false
               get 'projects/:id/repository/:repository_id/revisions/:rev', :to => 'repositories#revision'
               get 'projects/:id/repository/:repository_id/revision', :to => 'repositories#revision'
               post   'projects/:id/repository/:repository_id/revisions/:rev/issues', :to => 'repositories#add_related_issue'
               delete 'projects/:id/repository/:repository_id/revisions/:rev/issues/:issue_id', :to => 'repositories#remove_related_issue'
               get 'projects/:id/repository/:repository_id/revisions', :to => 'repositories#revisions'
               get 'projects/:id/repository/:repository_id/revisions/:rev/:action(/*path)',
                   :controller => 'repositories',
                   :format => false,
                   :constraints => {
                         :action => /(browse|show|entry|raw|annotate|diff)/,
                         :rev    => /[a-z0-9\.\-_]+/
                       }
               get 'projects/:id/repository/statistics', :to => 'repositories#stats'
               get 'projects/:id/repository/graph', :to => 'repositories#graph'
               get 'projects/:id/repository/changes(/*path)',
                   :to => 'repositories#changes',
                   :format => false
               get 'projects/:id/repository/revisions', :to => 'repositories#revisions'
               get 'projects/:id/repository/revisions/:rev', :to => 'repositories#revision'
               get 'projects/:id/repository/revision', :to => 'repositories#revision'
               post   'projects/:id/repository/revisions/:rev/issues', :to => 'repositories#add_related_issue'
               delete 'projects/:id/repository/revisions/:rev/issues/:issue_id', :to => 'repositories#remove_related_issue'
               get 'projects/:id/repository/revisions/:rev/:action(/*path)',
                   :controller => 'repositories',
                   :format => false,
                   :constraints => {
                         :action => /(browse|show|entry|raw|annotate|diff)/,
                         :rev    => /[a-z0-9\.\-_]+/
                       }
               get 'projects/:id/repository/:repository_id/:action(/*path)',
                   :controller => 'repositories',
                   :action => /(browse|show|entry|raw|changes|annotate|diff)/,
                   :format => false
               get 'projects/:id/repository/:action(/*path)',
                   :controller => 'repositories',
                   :action => /(browse|show|entry|raw|changes|annotate|diff)/,
                   :format => false
               get 'projects/:id/repository/:repository_id', :to => 'repositories#show', :path => nil
               get 'projects/:id/repository', :to => 'repositories#show', :path => nil
               # additional routes for having the file name at the end of url
               get 'attachments/:id/:filename', :to => 'attachments#show', :id => /\d+/, :filename => /.*/, :as => 'named_attachment'
               get 'attachments/download/:id/:filename', :to => 'attachments#download', :id => /\d+/, :filename => /.*/, :as => 'download_named_attachment'
               get 'attachments/download/:id', :to => 'attachments#download', :id => /\d+/
               get 'attachments/thumbnail/:id(/:size)', :to => 'attachments#thumbnail', :id => /\d+/, :size => /\d+/, :as => 'thumbnail'
               resources :attachments, :only => [:show, :destroy]
               get 'attachments/:object_type/:object_id/edit', :to => 'attachments#edit', :as => :object_attachments_edit
               patch 'attachments/:object_type/:object_id', :to => 'attachments#update', :as => :object_attachments
               resources :groups do
                 resources :memberships, :controller => 'principal_memberships'
                 member do
                   get 'autocomplete_for_user'
                 end
               end
               get 'groups/:id/users/new', :to => 'groups#new_users', :id => /\d+/, :as => 'new_group_users'
               post 'groups/:id/users', :to => 'groups#add_users', :id => /\d+/, :as => 'group_users'
               delete 'groups/:id/users/:user_id', :to => 'groups#remove_user', :id => /\d+/, :as => 'group_user'
               resources :trackers, :except => :show do
                 collection do
                   match 'fields', :via => [:get, :post]
                 end
               end
               resources :issue_statuses, :except => :show do
                 collection do
                   post 'update_issue_done_ratio'
                 end
               end
               resources :custom_fields, :except => :show do
                 resources :enumerations, :controller => 'custom_field_enumerations', :except => [:show, :new, :edit]
                 put 'enumerations', :to => 'custom_field_enumerations#update_each'
               end
               resources :roles do
                 collection do
                   match 'permissions', :via => [:get, :post]
                 end
               end
               resources :enumerations, :except => :show
               match 'enumerations/:type', :to => 'enumerations#index', :via => :get
               get 'projects/:id/search', :controller => 'search', :action => 'index'
               get 'search', :controller => 'search', :action => 'index'
               get  'mail_handler', :to => 'mail_handler#new'
               post 'mail_handler', :to => 'mail_handler#index'
               get 'admin', :to => 'admin#index'
               get 'admin/projects', :to => 'admin#projects'
               get 'admin/plugins', :to => 'admin#plugins'
               get 'admin/info', :to => 'admin#info'
               post 'admin/test_email', :to => 'admin#test_email', :as => 'test_email'
               post 'admin/default_configuration', :to => 'admin#default_configuration'
               resources :auth_sources do
                 member do
                   get 'test_connection', :as => 'try_connection'
                 end
                 collection do
                   get 'autocomplete_for_new_user'
                 end
               end
               match 'workflows', :controller => 'workflows', :action => 'index', :via => :get
               match 'workflows/edit', :controller => 'workflows', :action => 'edit', :via => [:get, :post]
               match 'workflows/permissions', :controller => 'workflows', :action => 'permissions', :via => [:get, :post]
               match 'workflows/copy', :controller => 'workflows', :action => 'copy', :via => [:get, :post]
               match 'settings', :controller => 'settings', :action => 'index', :via => :get
               match 'settings/edit', :controller => 'settings', :action => 'edit', :via => [:get, :post]
               match 'settings/plugin/:id', :controller => 'settings', :action => 'plugin', :via => [:get, :post], :as => 'plugin_settings'
               match 'sys/projects', :to => 'sys#projects', :via => :get
               match 'sys/projects/:id/repository', :to => 'sys#create_project_repository', :via => :post
               match 'sys/fetch_changesets', :to => 'sys#fetch_changesets', :via => [:get, :post]
               match 'uploads', :to => 'attachments#upload', :via => :post
               get 'robots.txt', :to => 'welcome#robots'
               Dir.glob File.expand_path("plugins/*", Rails.root) do |plugin_dir|
                 file = File.join(plugin_dir, "config/routes.rb")
                 if File.exists?(file)
                   begin
                     instance_eval File.read(file)
                   rescue Exception => e
                     puts "An error occurred while loading the routes definition of #{File.basename(plugin_dir)} plugin (#{file}): #{e.message}."
                     exit 1
                   end
                 end
               end
             end

lib/redmine.rb +2 -2

             # Redmine - project management software
             # Copyright (C) 2006-2015  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 'redmine/core_ext'
             begin
               require 'rmagick' unless Object.const_defined?(:Magick)
             rescue LoadError
               # RMagick is not available
             end
             begin
               require 'redcarpet' unless Object.const_defined?(:Redcarpet)
             rescue LoadError
               # Redcarpet is not available
             end
             require 'redmine/scm/base'
             require 'redmine/access_control'
             require 'redmine/access_keys'
             require 'redmine/activity'
             require 'redmine/activity/fetcher'
             require 'redmine/ciphering'
             require 'redmine/codeset_util'
             require 'redmine/field_format'
             require 'redmine/menu_manager'
             require 'redmine/notifiable'
             require 'redmine/platform'
             require 'redmine/mime_type'
             require 'redmine/notifiable'
             require 'redmine/search'
             require 'redmine/syntax_highlighting'
             require 'redmine/thumbnail'
             require 'redmine/unified_diff'
             require 'redmine/utils'
             require 'redmine/version'
             require 'redmine/wiki_formatting'
             require 'redmine/default_data/loader'
             require 'redmine/helpers/calendar'
             require 'redmine/helpers/diff'
             require 'redmine/helpers/gantt'
             require 'redmine/helpers/time_report'
             require 'redmine/views/other_formats_builder'
             require 'redmine/views/labelled_form_builder'
             require 'redmine/views/builders'
             require 'redmine/themes'
             require 'redmine/hook'
             require 'redmine/hook/listener'
             require 'redmine/hook/view_listener'
             require 'redmine/plugin'
             Redmine::Scm::Base.add "Subversion"
             Redmine::Scm::Base.add "Darcs"
             Redmine::Scm::Base.add "Mercurial"
             Redmine::Scm::Base.add "Cvs"
             Redmine::Scm::Base.add "Bazaar"
             Redmine::Scm::Base.add "Git"
             Redmine::Scm::Base.add "Filesystem"
             # Permissions
             Redmine::AccessControl.map do |map|
               map.permission :view_project, {:projects => [:show], :activities => [:index]}, :public => true, :read => true
               map.permission :search_project, {:search => :index}, :public => true, :read => true
               map.permission :add_project, {:projects => [:new, :create]}, :require => :loggedin
               map.permission :edit_project, {:projects => [:settings, :edit, :update]}, :require => :member
               map.permission :close_project, {:projects => [:close, :reopen]}, :require => :member, :read => true
               map.permission :select_project_modules, {:projects => :modules}, :require => :member
               map.permission :view_members, {:members => [:index, :show]}, :public => true, :read => true
               map.permission :manage_members, {:projects => :settings, :members => [:index, :show, :new, :create, :update, :destroy, :autocomplete]}, :require => :member
               map.permission :manage_versions, {:projects => :settings, :versions => [:new, :create, :edit, :update, :close_completed, :destroy]}, :require => :member
               map.permission :add_subprojects, {:projects => [:new, :create]}, :require => :member
               map.project_module :issue_tracking do |map|
                 # Issue categories
                 map.permission :manage_categories, {:projects => :settings, :issue_categories => [:index, :show, :new, :create, :edit, :update, :destroy]}, :require => :member
                 # Issues
                 map.permission :view_issues, {:issues => [:index, :show],
                                               :auto_complete => [:issues],
                                               :context_menus => [:issues],
                                               :versions => [:index, :show, :status_by],
                                               :journals => [:index, :diff],
                                               :queries => :index,
                                               :reports => [:issue_report, :issue_report_details]},
                                               :read => true
                 map.permission :add_issues, {:issues => [:new, :create], :attachments => :upload}
                 map.permission :edit_issues, {:issues => [:edit, :update, :bulk_edit, :bulk_update], :journals => [:new], :attachments => :upload}
                 map.permission :copy_issues, {:issues => [:new, :create, :bulk_edit, :bulk_update], :attachments => :upload}
                 map.permission :manage_issue_relations, {:issue_relations => [:index, :show, :create, :destroy]}
                 map.permission :manage_subtasks, {}
                 map.permission :set_issues_private, {}
                 map.permission :set_own_issues_private, {}, :require => :loggedin
                 map.permission :add_issue_notes, {:issues => [:edit, :update], :journals => [:new], :attachments => :upload}
-                map.permission :edit_issue_notes, {:journals => :edit}, :require => :loggedin
+                map.permission :edit_issue_notes, {:journals => [:edit, :update]}, :require => :loggedin
-                map.permission :edit_own_issue_notes, {:journals => :edit}, :require => :loggedin
+                map.permission :edit_own_issue_notes, {:journals => [:edit, :update]}, :require => :loggedin
                 map.permission :view_private_notes, {}, :read => true, :require => :member
                 map.permission :set_notes_private, {}, :require => :member
                 map.permission :delete_issues, {:issues => :destroy}, :require => :member
                 # Queries
                 map.permission :manage_public_queries, {:queries => [:new, :create, :edit, :update, :destroy]}, :require => :member
                 map.permission :save_queries, {:queries => [:new, :create, :edit, :update, :destroy]}, :require => :loggedin
                 # Watchers
                 map.permission :view_issue_watchers, {}, :read => true
                 map.permission :add_issue_watchers, {:watchers => [:new, :create, :append, :autocomplete_for_user]}
                 map.permission :delete_issue_watchers, {:watchers => :destroy}
                 map.permission :import_issues, {:imports => [:new, :create, :settings, :mapping, :run, :show]}
               end
               map.project_module :time_tracking do |map|
                 map.permission :log_time, {:timelog => [:new, :create]}, :require => :loggedin
                 map.permission :view_time_entries, {:timelog => [:index, :report, :show]}, :read => true
                 map.permission :edit_time_entries, {:timelog => [:edit, :update, :destroy, :bulk_edit, :bulk_update]}, :require => :member
                 map.permission :edit_own_time_entries, {:timelog => [:edit, :update, :destroy,:bulk_edit, :bulk_update]}, :require => :loggedin
                 map.permission :manage_project_activities, {:project_enumerations => [:update, :destroy]}, :require => :member
               end
               map.project_module :news do |map|
                 map.permission :manage_news, {:news => [:new, :create, :edit, :update, :destroy], :comments => [:destroy], :attachments => :upload}, :require => :member
                 map.permission :view_news, {:news => [:index, :show]}, :public => true, :read => true
                 map.permission :comment_news, {:comments => :create}
               end
               map.project_module :documents do |map|
                 map.permission :add_documents, {:documents => [:new, :create, :add_attachment], :attachments => :upload}, :require => :loggedin
                 map.permission :edit_documents, {:documents => [:edit, :update, :add_attachment], :attachments => :upload}, :require => :loggedin
                 map.permission :delete_documents, {:documents => [:destroy]}, :require => :loggedin
                 map.permission :view_documents, {:documents => [:index, :show, :download]}, :read => true
               end
               map.project_module :files do |map|
                 map.permission :manage_files, {:files => [:new, :create], :attachments => :upload}, :require => :loggedin
                 map.permission :view_files, {:files => :index, :versions => :download}, :read => true
               end
               map.project_module :wiki do |map|
                 map.permission :manage_wiki, {:wikis => [:edit, :destroy]}, :require => :member
                 map.permission :rename_wiki_pages, {:wiki => :rename}, :require => :member
                 map.permission :delete_wiki_pages, {:wiki => [:destroy, :destroy_version]}, :require => :member
                 map.permission :view_wiki_pages, {:wiki => [:index, :show, :special, :date_index]}, :read => true
                 map.permission :export_wiki_pages, {:wiki => [:export]}, :read => true
                 map.permission :view_wiki_edits, {:wiki => [:history, :diff, :annotate]}, :read => true
                 map.permission :edit_wiki_pages, :wiki => [:edit, :update, :preview, :add_attachment], :attachments => :upload
                 map.permission :delete_wiki_pages_attachments, {}
                 map.permission :protect_wiki_pages, {:wiki => :protect}, :require => :member
               end
               map.project_module :repository do |map|
                 map.permission :manage_repository, {:repositories => [:new, :create, :edit, :update, :committers, :destroy]}, :require => :member
                 map.permission :browse_repository, {:repositories => [:show, :browse, :entry, :raw, :annotate, :changes, :diff, :stats, :graph]}, :read => true
                 map.permission :view_changesets, {:repositories => [:show, :revisions, :revision]}, :read => true
                 map.permission :commit_access, {}
                 map.permission :manage_related_issues, {:repositories => [:add_related_issue, :remove_related_issue]}
               end
               map.project_module :boards do |map|
                 map.permission :manage_boards, {:boards => [:new, :create, :edit, :update, :destroy]}, :require => :member
                 map.permission :view_messages, {:boards => [:index, :show], :messages => [:show]}, :public => true, :read => true
                 map.permission :add_messages, {:messages => [:new, :reply, :quote], :attachments => :upload}
                 map.permission :edit_messages, {:messages => :edit, :attachments => :upload}, :require => :member
                 map.permission :edit_own_messages, {:messages => :edit, :attachments => :upload}, :require => :loggedin
                 map.permission :delete_messages, {:messages => :destroy}, :require => :member
                 map.permission :delete_own_messages, {:messages => :destroy}, :require => :loggedin
               end
               map.project_module :calendar do |map|
                 map.permission :view_calendar, {:calendars => [:show, :update]}, :read => true
               end
               map.project_module :gantt do |map|
                 map.permission :view_gantt, {:gantts => [:show, :update]}, :read => true
               end
             end
             Redmine::MenuManager.map :top_menu do |menu|
               menu.push :home, :home_path
               menu.push :my_page, { :controller => 'my', :action => 'page' }, :if => Proc.new { User.current.logged? }
               menu.push :projects, { :controller => 'projects', :action => 'index' }, :caption => :label_project_plural
               menu.push :administration, { :controller => 'admin', :action => 'index' }, :if => Proc.new { User.current.admin? }, :last => true
               menu.push :help, Redmine::Info.help_url, :last => true
             end
             Redmine::MenuManager.map :account_menu do |menu|
               menu.push :login, :signin_path, :if => Proc.new { !User.current.logged? }
               menu.push :register, :register_path, :if => Proc.new { !User.current.logged? && Setting.self_registration? }
               menu.push :my_account, { :controller => 'my', :action => 'account' }, :if => Proc.new { User.current.logged? }
               menu.push :logout, :signout_path, :html => {:method => 'post'}, :if => Proc.new { User.current.logged? }
             end
             Redmine::MenuManager.map :application_menu do |menu|
               # Empty
             end
             Redmine::MenuManager.map :admin_menu do |menu|
               menu.push :projects, {:controller => 'admin', :action => 'projects'}, :caption => :label_project_plural
               menu.push :users, {:controller => 'users'}, :caption => :label_user_plural
               menu.push :groups, {:controller => 'groups'}, :caption => :label_group_plural
               menu.push :roles, {:controller => 'roles'}, :caption => :label_role_and_permissions
               menu.push :trackers, {:controller => 'trackers'}, :caption => :label_tracker_plural
               menu.push :issue_statuses, {:controller => 'issue_statuses'}, :caption => :label_issue_status_plural,
                         :html => {:class => 'issue_statuses'}
               menu.push :workflows, {:controller => 'workflows', :action => 'edit'}, :caption => :label_workflow
               menu.push :custom_fields, {:controller => 'custom_fields'},  :caption => :label_custom_field_plural,
                         :html => {:class => 'custom_fields'}
               menu.push :enumerations, {:controller => 'enumerations'}
               menu.push :settings, {:controller => 'settings'}
               menu.push :ldap_authentication, {:controller => 'auth_sources', :action => 'index'},
                         :html => {:class => 'server_authentication'}
               menu.push :plugins, {:controller => 'admin', :action => 'plugins'}, :last => true
               menu.push :info, {:controller => 'admin', :action => 'info'}, :caption => :label_information_plural, :last => true
             end
             Redmine::MenuManager.map :project_menu do |menu|
               menu.push :overview, { :controller => 'projects', :action => 'show' }
               menu.push :activity, { :controller => 'activities', :action => 'index' }
               menu.push :roadmap, { :controller => 'versions', :action => 'index' }, :param => :project_id,
                           :if => Proc.new { |p| p.shared_versions.any? }
               menu.push :issues, { :controller => 'issues', :action => 'index' }, :param => :project_id, :caption => :label_issue_plural
               menu.push :new_issue, { :controller => 'issues', :action => 'new', :copy_from => nil }, :param => :project_id, :caption => :label_issue_new,
                           :html => { :accesskey => Redmine::AccessKeys.key_for(:new_issue) },
                           :if => Proc.new { |p| p.trackers.any? },
                           :permission => :add_issues
               menu.push :gantt, { :controller => 'gantts', :action => 'show' }, :param => :project_id, :caption => :label_gantt
               menu.push :calendar, { :controller => 'calendars', :action => 'show' }, :param => :project_id, :caption => :label_calendar
               menu.push :news, { :controller => 'news', :action => 'index' }, :param => :project_id, :caption => :label_news_plural
               menu.push :documents, { :controller => 'documents', :action => 'index' }, :param => :project_id, :caption => :label_document_plural
               menu.push :wiki, { :controller => 'wiki', :action => 'show', :id => nil }, :param => :project_id,
                           :if => Proc.new { |p| p.wiki && !p.wiki.new_record? }
               menu.push :boards, { :controller => 'boards', :action => 'index', :id => nil }, :param => :project_id,
                           :if => Proc.new { |p| p.boards.any? }, :caption => :label_board_plural
               menu.push :files, { :controller => 'files', :action => 'index' }, :caption => :label_file_plural, :param => :project_id
               menu.push :repository, { :controller => 'repositories', :action => 'show', :repository_id => nil, :path => nil, :rev => nil },
                           :if => Proc.new { |p| p.repository && !p.repository.new_record? }
               menu.push :settings, { :controller => 'projects', :action => 'settings' }, :last => true
             end
             Redmine::Activity.map do |activity|
               activity.register :issues, :class_name => %w(Issue Journal)
               activity.register :changesets
               activity.register :news
               activity.register :documents, :class_name => %w(Document Attachment)
               activity.register :files, :class_name => 'Attachment'
               activity.register :wiki_edits, :class_name => 'WikiContent::Version', :default => false
               activity.register :messages, :default => false
               activity.register :time_entries, :default => false
             end
             Redmine::Search.map do |search|
               search.register :issues
               search.register :news
               search.register :documents
               search.register :changesets
               search.register :wiki_pages
               search.register :messages
               search.register :projects
             end
             Redmine::WikiFormatting.map do |format|
               format.register :textile
               format.register :markdown if Object.const_defined?(:Redcarpet)
             end
             ActionView::Template.register_template_handler :rsb, Redmine::Views::ApiTemplateHandler

test/functional/journals_controller_test.rb +2 -2

             # Redmine - project management software
             # Copyright (C) 2006-2015  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 JournalsControllerTest < ActionController::TestCase
               fixtures :projects, :users, :members, :member_roles, :roles, :issues, :journals, :journal_details, :enabled_modules,
                 :trackers, :issue_statuses, :enumerations, :custom_fields, :custom_values, :custom_fields_projects, :projects_trackers
               def setup
                 User.current = nil
               end
               def test_index
                 get :index, :project_id => 1
                 assert_response :success
                 assert_not_nil assigns(:journals)
                 assert_equal 'application/atom+xml', @response.content_type
               end
               def test_index_with_invalid_query_id
                 get :index, :project_id => 1, :query_id => 999
                 assert_response 404
               end
               def test_index_should_return_privates_notes_with_permission_only
                 journal = Journal.create!(:journalized => Issue.find(2), :notes => 'Privates notes', :private_notes => true, :user_id => 1)
                 @request.session[:user_id] = 2
                 get :index, :project_id => 1
                 assert_response :success
                 assert_include journal, assigns(:journals)
                 Role.find(1).remove_permission! :view_private_notes
                 get :index, :project_id => 1
                 assert_response :success
                 assert_not_include journal, assigns(:journals)
               end
               def test_index_should_show_visible_custom_fields_only
                 Issue.destroy_all
                 field_attributes = {:field_format => 'string', :is_for_all => true, :is_filter => true, :trackers => Tracker.all}
                 @fields = []
                 @fields << (@field1 = IssueCustomField.create!(field_attributes.merge(:name => 'Field 1', :visible => true)))
                 @fields << (@field2 = IssueCustomField.create!(field_attributes.merge(:name => 'Field 2', :visible => false, :role_ids => [1, 2])))
                 @fields << (@field3 = IssueCustomField.create!(field_attributes.merge(:name => 'Field 3', :visible => false, :role_ids => [1, 3])))
                 @issue = Issue.generate!(
                   :author_id => 1,
                   :project_id => 1,
                   :tracker_id => 1,
                   :custom_field_values => {@field1.id => 'Value0', @field2.id => 'Value1', @field3.id => 'Value2'}
                 )
                 @issue.init_journal(User.find(1))
                 @issue.update_attribute :custom_field_values, {@field1.id => 'NewValue0', @field2.id => 'NewValue1', @field3.id => 'NewValue2'}
                 user_with_role_on_other_project = User.generate!
                 User.add_to_project(user_with_role_on_other_project, Project.find(2), Role.find(3))
                 users_to_test = {
                   User.find(1) => [@field1, @field2, @field3],
                   User.find(3) => [@field1, @field2],
                   user_with_role_on_other_project => [@field1], # should see field1 only on Project 1
                   User.generate! => [@field1],
                   User.anonymous => [@field1]
                 }
                 users_to_test.each do |user, visible_fields|
                   get :index, :format => 'atom', :key => user.rss_key
                   @fields.each_with_index do |field, i|
                     if visible_fields.include?(field)
                       assert_select "content[type=html]", { :text => /NewValue#{i}/, :count => 1 }, "User #{user.id} was not able to view #{field.name} in API"
                     else
                       assert_select "content[type=html]", { :text => /NewValue#{i}/, :count => 0 }, "User #{user.id} was able to view #{field.name} in API"
                     end
                   end
                 end
               end
               def test_diff_for_description_change
                 get :diff, :id => 3, :detail_id => 4
                 assert_response :success
                 assert_template 'diff'
                 assert_select 'span.diff_out', :text => /removed/
                 assert_select 'span.diff_in', :text => /added/
               end
               def test_diff_for_custom_field
                 field = IssueCustomField.create!(:name => "Long field", :field_format => 'text')
                 journal = Journal.create!(:journalized => Issue.find(2), :notes => 'Notes', :user_id => 1)
                 detail = JournalDetail.create!(:journal => journal, :property => 'cf', :prop_key => field.id,
                   :old_value => 'Foo', :value => 'Bar')
                 get :diff, :id => journal.id, :detail_id => detail.id
                 assert_response :success
                 assert_template 'diff'
                 assert_select 'span.diff_out', :text => /Foo/
                 assert_select 'span.diff_in', :text => /Bar/
               end
               def test_diff_for_custom_field_should_be_denied_if_custom_field_is_not_visible
                 field = IssueCustomField.create!(:name => "Long field", :field_format => 'text', :visible => false, :role_ids => [1])
                 journal = Journal.create!(:journalized => Issue.find(2), :notes => 'Notes', :user_id => 1)
                 detail = JournalDetail.create!(:journal => journal, :property => 'cf', :prop_key => field.id,
                   :old_value => 'Foo', :value => 'Bar')
                 get :diff, :id => journal.id, :detail_id => detail.id
                 assert_response 302
               end
               def test_diff_should_default_to_description_diff
                 get :diff, :id => 3
                 assert_response :success
                 assert_template 'diff'
                 assert_select 'span.diff_out', :text => /removed/
                 assert_select 'span.diff_in', :text => /added/
               end
               def test_reply_to_issue
                 @request.session[:user_id] = 2
                 xhr :get, :new, :id => 6
                 assert_response :success
                 assert_template 'new'
                 assert_equal 'text/javascript', response.content_type
                 assert_include '> This is an issue', response.body
               end
               def test_reply_to_issue_without_permission
                 @request.session[:user_id] = 7
                 xhr :get, :new, :id => 6
                 assert_response 403
               end
               def test_reply_to_note
                 @request.session[:user_id] = 2
                 xhr :get, :new, :id => 6, :journal_id => 4
                 assert_response :success
                 assert_template 'new'
                 assert_equal 'text/javascript', response.content_type
                 assert_include '> A comment with a private version', response.body
               end
               def test_reply_to_private_note_should_fail_without_permission
                 journal = Journal.create!(:journalized => Issue.find(2), :notes => 'Privates notes', :private_notes => true)
                 @request.session[:user_id] = 2
                 xhr :get, :new, :id => 2, :journal_id => journal.id
                 assert_response :success
                 assert_template 'new'
                 assert_equal 'text/javascript', response.content_type
                 assert_include '> Privates notes', response.body
                 Role.find(1).remove_permission! :view_private_notes
                 xhr :get, :new, :id => 2, :journal_id => journal.id
                 assert_response 404
               end
               def test_edit_xhr
                 @request.session[:user_id] = 1
                 xhr :get, :edit, :id => 2
                 assert_response :success
                 assert_template 'edit'
                 assert_equal 'text/javascript', response.content_type
                 assert_include 'textarea', response.body
               end
               def test_edit_private_note_should_fail_without_permission
                 journal = Journal.create!(:journalized => Issue.find(2), :notes => 'Privates notes', :private_notes => true)
                 @request.session[:user_id] = 2
                 Role.find(1).add_permission! :edit_issue_notes
                 xhr :get, :edit, :id => journal.id
                 assert_response :success
                 assert_template 'edit'
                 assert_equal 'text/javascript', response.content_type
                 assert_include 'textarea', response.body
                 Role.find(1).remove_permission! :view_private_notes
                 xhr :get, :edit, :id => journal.id
                 assert_response 404
               end
               def test_update_xhr
                 @request.session[:user_id] = 1
-                xhr :post, :edit, :id => 2, :notes => 'Updated notes'
+                xhr :post, :update, :id => 2, :notes => 'Updated notes'
                 assert_response :success
                 assert_template 'update'
                 assert_equal 'text/javascript', response.content_type
                 assert_equal 'Updated notes', Journal.find(2).notes
                 assert_include 'journal-2-notes', response.body
               end
               def test_update_xhr_with_empty_notes_should_delete_the_journal
                 @request.session[:user_id] = 1
                 assert_difference 'Journal.count', -1 do
-                  xhr :post, :edit, :id => 2, :notes => ''
+                  xhr :post, :update, :id => 2, :notes => ''
                   assert_response :success
                   assert_template 'update'
                   assert_equal 'text/javascript', response.content_type
                 end
                 assert_nil Journal.find_by_id(2)
                 assert_include 'change-2', response.body
               end
             end

test/integration/routing/journals_test.rb +3 -3

             # Redmine - project management software
             # Copyright (C) 2006-2015  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 RoutingJournalsTest < Redmine::RoutingTest
               def test_journals
                 should_route 'POST /issues/1/quoted' => 'journals#new', :id => '1'
                 should_route 'GET /issues/changes' => 'journals#index'
-                should_route 'GET /journals/diff/1' => 'journals#diff', :id => '1'
+                should_route 'GET /journals/1/diff' => 'journals#diff', :id => '1'
-                should_route 'GET /journals/edit/1' => 'journals#edit', :id => '1'
+                should_route 'GET /journals/1/edit' => 'journals#edit', :id => '1'
-                should_route 'POST /journals/edit/1' => 'journals#edit', :id => '1'
+                should_route 'PUT /journals/1' => 'journals#update', :id => '1'
               end
             end

test/unit/mailer_test.rb +3 -3

             # Redmine - project management software
             # Copyright (C) 2006-2015  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 Rails::Dom::Testing::Assertions
               fixtures :projects, :enabled_modules, :issues, :users, :email_addresses, :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'
                 Setting.default_language = 'en'
                 User.current = nil
               end
               def test_generated_links_in_emails
                 Setting.host_name = 'mydomain.foo'
                 Setting.protocol = 'https'
                 journal = Journal.find(3)
                 assert Mailer.deliver_issue_edit(journal)
                 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',
                                 "Bug: Cannot 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 & #3',
                                 :text => 'r2'
                   # link to a description diff
                   assert_select 'a[href^=?][title=?]',
                                 # should be https://mydomain.foo/journals/diff/3?detail_id=4
                                 # but the Rails 4.2 DOM assertion doesn't handle the ? in the
                                 # attribute value
-                                'https://mydomain.foo/journals/diff/3',
+                                'https://mydomain.foo/journals/3/diff',
                                 '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
                 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)
                 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',
                                 "Bug: Cannot 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 & #3',
                                 :text => 'r2'
                   # link to a description diff
                   assert_select 'a[href^=?][title=?]',
                                 # should be http://mydomain.foo/rdm/journals/diff/3?detail_id=4
                                 # but the Rails 4.2 DOM assertion doesn't handle the ? in the
                                 # attribute value
-                                'http://mydomain.foo/rdm/journals/diff/3',
+                                'http://mydomain.foo/rdm/journals/3/diff',
                                 '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_port_and_prefix
                 with_settings :host_name => '10.0.0.1:81/redmine', :protocol => 'http' do
                   Mailer.test_email(User.find(1)).deliver
                   mail = last_email
                   assert_not_nil mail
                   assert_include 'http://10.0.0.1:81/redmine', mail_body(mail)
                 end
               end
               def test_generated_links_with_port
                 with_settings :host_name => '10.0.0.1:81', :protocol => 'http' do
                   Mailer.test_email(User.find(1)).deliver
                   mail = last_email
                   assert_not_nil mail
                   assert_include 'http://10.0.0.1:81', mail_body(mail)
                 end
               end
               def test_issue_edit_should_generate_url_with_hostname_for_relations
                 journal = Journal.new(:journalized => Issue.find(1), :user => User.find(1), :created_on => Time.now)
                 journal.details << JournalDetail.new(:property => 'relation', :prop_key => 'label_relates_to', :value => 2)
                 Mailer.deliver_issue_edit(journal)
                 assert_not_nil last_email
                 assert_select_email do
                   assert_select 'a[href=?]', 'http://mydomain.foo/issues/2', :text => 'Feature request #2'
                 end
               end
               def test_generated_links_with_prefix_and_no_relative_url_root
                 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)
                 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',
                                 "Bug: Cannot 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 & #3',
                                 :text => 'r2'
                   # link to a description diff
                   assert_select 'a[href^=?][title=?]',
                                 # should be http://mydomain.foo/rdm/journals/diff/3?detail_id=4
                                 # but the Rails 4.2 DOM assertion doesn't handle the ? in the
                                 # attribute value
-                                'http://mydomain.foo/rdm/journals/diff/3',
+                                'http://mydomain.foo/rdm/journals/3/diff',
                                 '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)
                 mail = last_email
                 assert_not_nil mail
                 assert_equal 'All', mail.header['X-Auto-Response-Suppress'].to_s
                 assert_equal 'auto-generated', mail.header['Auto-Submitted'].to_s
                 assert_equal '<redmine.example.net>', mail.header['List-Id'].to_s
               end
               def test_email_headers_should_include_sender
                 issue = Issue.find(1)
                 Mailer.deliver_issue_add(issue)
                 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)
                 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)
                 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.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.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.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.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.news_added(news.reload).deliver
                 assert ActionMailer::Base.deliveries.empty?
               end
               def test_issue_add_message_id
                 issue = Issue.find(2)
                 Mailer.deliver_issue_add(issue)
                 mail = last_email
                 assert_match /^redmine\.issue-2\.20060719190421\.[a-f0-9]+@example\.net/, mail.message_id
                 assert_include "redmine.issue-2.20060719190421@example.net", mail.references
               end
               def test_issue_edit_message_id
                 journal = Journal.find(3)
                 journal.issue = Issue.find(2)
                 Mailer.deliver_issue_edit(journal)
                 mail = last_email
                 assert_match /^redmine\.journal-3\.\d+\.[a-f0-9]+@example\.net/, mail.message_id
                 assert_include "redmine.issue-2.20060719190421@example.net", 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.message_posted(message).deliver
                 mail = last_email
                 assert_match /^redmine\.message-1\.\d+\.[a-f0-9]+@example\.net/, mail.message_id
                 assert_include "redmine.message-1.20070512151532@example.net", 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.message_posted(message).deliver
                 mail = last_email
                 assert_match /^redmine\.message-3\.\d+\.[a-f0-9]+@example\.net/, mail.message_id
                 assert_include "redmine.message-1.20070512151532@example.net", 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
               test "#issue_add should notify project members" do
                 issue = Issue.find(1)
                 assert Mailer.deliver_issue_add(issue)
                 assert last_email.bcc.include?('dlopper@somenet.foo')
               end
               def test_issue_add_should_send_mail_to_all_user_email_address
                 EmailAddress.create!(:user_id => 3, :address => 'otheremail@somenet.foo')
                 issue = Issue.find(1)
                 assert Mailer.deliver_issue_add(issue)
                 assert last_email.bcc.include?('dlopper@somenet.foo')
                 assert last_email.bcc.include?('otheremail@somenet.foo')
               end
               test "#issue_add should not notify project members that are not allow to view the issue" do
                 issue = Issue.find(1)
                 Role.find(2).remove_permission!(:view_issues)
                 assert Mailer.deliver_issue_add(issue)
                 assert !last_email.bcc.include?('dlopper@somenet.foo')
               end
               test "#issue_add should notify issue watchers" do
                 issue = Issue.find(1)
                 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 last_email.bcc.include?(user.mail)
               end
               test "#issue_add should not notify watchers not allowed to view the issue" do
                 issue = Issue.find(1)
                 user = User.find(9)
                 Watcher.create!(:watchable => issue, :user => user)
                 Role.non_member.remove_permission!(:view_issues)
                 assert Mailer.deliver_issue_add(issue)
                 assert !last_email.bcc.include?(user.mail)
               end
               def test_issue_add_should_include_enabled_fields
                 issue = Issue.find(2)
                 assert Mailer.deliver_issue_add(issue)
                 assert_mail_body_match '* Target version: 1.0', last_email
                 assert_select_email do
                   assert_select 'li', :text => 'Target version: 1.0'
                 end
               end
               def test_issue_add_should_not_include_disabled_fields
                 issue = Issue.find(2)
                 tracker = issue.tracker
                 tracker.core_fields -= ['fixed_version_id']
                 tracker.save!
                 assert Mailer.deliver_issue_add(issue)
                 assert_mail_body_no_match 'Target version', last_email
                 assert_select_email do
                   assert_select 'li', :text => /Target version/, :count => 0
                 end
               end
               # test mailer methods for each language
               def test_issue_add
                 issue = Issue.find(1)
                 with_each_language_as_default do
                   assert Mailer.deliver_issue_add(issue)
                 end
               end
               def test_issue_edit
                 journal = Journal.find(1)
                 with_each_language_as_default do
                   assert Mailer.deliver_issue_edit(journal)
                 end
               end
               def test_issue_edit_should_send_private_notes_to_users_with_permission_only
                 journal = Journal.find(1)
                 journal.private_notes = true
                 journal.save!
                 Role.find(2).add_permission! :view_private_notes
                 Mailer.deliver_issue_edit(journal)
                 assert_equal %w(dlopper@somenet.foo jsmith@somenet.foo), ActionMailer::Base.deliveries.last.bcc.sort
                 Role.find(2).remove_permission! :view_private_notes
                 Mailer.deliver_issue_edit(journal)
                 assert_equal %w(jsmith@somenet.foo), ActionMailer::Base.deliveries.last.bcc.sort
               end
               def test_issue_edit_should_send_private_notes_to_watchers_with_permission_only
                 Issue.find(1).set_watcher(User.find_by_login('someone'))
                 journal = Journal.find(1)
                 journal.private_notes = true
                 journal.save!
                 Role.non_member.add_permission! :view_private_notes
                 Mailer.deliver_issue_edit(journal)
                 assert_include 'someone@foo.bar', ActionMailer::Base.deliveries.last.bcc.sort
                 Role.non_member.remove_permission! :view_private_notes
                 Mailer.deliver_issue_edit(journal)
                 assert_not_include 'someone@foo.bar', ActionMailer::Base.deliveries.last.bcc.sort
               end
               def test_issue_edit_should_mark_private_notes
                 journal = Journal.find(2)
                 journal.private_notes = true
                 journal.save!
                 with_settings :default_language => 'en' do
                   Mailer.deliver_issue_edit(journal)
                 end
                 assert_mail_body_match '(Private notes)', last_email
               end
               def test_issue_edit_with_relation_should_notify_users_who_can_see_the_related_issue
                 issue = Issue.generate!
                 issue.init_journal(User.find(1))
                 private_issue = Issue.generate!(:is_private => true)
                 IssueRelation.create!(:issue_from => issue, :issue_to => private_issue, :relation_type => 'relates')
                 issue.reload
                 assert_equal 1, issue.journals.size
                 journal = issue.journals.first
                 ActionMailer::Base.deliveries.clear
                 Mailer.deliver_issue_edit(journal)
                 last_email.bcc.each do |email|
                   user = User.find_by_mail(email)
                   assert private_issue.visible?(user), "Issue was not visible to #{user}"
                 end
               end
               def test_document_added
                 document = Document.find(1)
                 with_each_language_as_default do
                   assert Mailer.document_added(document).deliver
                 end
               end
               def test_attachments_added
                 attachements = [ Attachment.find_by_container_type('Document') ]
                 with_each_language_as_default do
                   assert Mailer.attachments_added(attachements).deliver
                 end
               end
               def test_version_file_added
                 attachements = [ Attachment.find_by_container_type('Version') ]
                 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.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.first
                 with_each_language_as_default do
                   assert Mailer.news_added(news).deliver
                 end
               end
               def test_news_added_should_notify_project_news_watchers
                 user1 = User.generate!
                 user2 = User.generate!
                 news = News.find(1)
                 news.project.enabled_module('news').add_watcher(user1)
                 Mailer.news_added(news).deliver
                 assert_include user1.mail, last_email.bcc
                 assert_not_include user2.mail, last_email.bcc
               end
               def test_news_comment_added
                 comment = Comment.find(2)
                 with_each_language_as_default do
                   assert Mailer.news_comment_added(comment).deliver
                 end
               end
               def test_message_posted
                 message = Message.first
                 recipients = ([message.root] + message.root.children).collect {|m| m.author.mail if m.author}
                 recipients = recipients.compact.uniq
                 with_each_language_as_default do
                   assert Mailer.message_posted(message).deliver
                 end
               end
               def test_wiki_content_added
                 content = WikiContent.find(1)
                 with_each_language_as_default do
                   assert_difference 'ActionMailer::Base.deliveries.size' do
                     assert Mailer.wiki_content_added(content).deliver
                     assert_select_email do
                       assert_select 'a[href=?]',
                         'http://mydomain.foo/projects/ecookbook/wiki/CookBook_documentation',
                         :text => 'CookBook documentation'
                     end
                   end
                 end
               end
               def test_wiki_content_updated
                 content = WikiContent.find(1)
                 with_each_language_as_default do
                   assert_difference 'ActionMailer::Base.deliveries.size' do
                     assert Mailer.wiki_content_updated(content).deliver
                     assert_select_email do
                       assert_select 'a[href=?]',
                         'http://mydomain.foo/projects/ecookbook/wiki/CookBook_documentation',
                         :text => 'CookBook documentation'
                     end
                   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.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.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.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.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_reminder_should_include_issues_assigned_to_groups
                 with_settings :default_language => 'en' do
                   group = Group.generate!
                   group.users << User.find(2)
                   group.users << User.find(3)
                   Issue.create!(:project_id => 1, :tracker_id => 1, :status_id => 1,
                                   :subject => 'Assigned to group', :assigned_to => group,
                                   :due_date => 5.days.from_now,
                                   :author_id => 2)
                   ActionMailer::Base.deliveries.clear
                   Mailer.reminders(:days => 7)
                   assert_equal 2, ActionMailer::Base.deliveries.size
                   assert_equal %w(dlopper@somenet.foo jsmith@somenet.foo), ActionMailer::Base.deliveries.map(&:bcc).flatten.sort
                   ActionMailer::Base.deliveries.each do |mail|
                     assert_mail_body_match 'Assigned to group', mail
                   end
                 end
               end
               def test_reminders_with_version_option
                 with_settings :default_language => 'en' do
                   version = Version.generate!(:name => 'Acme', :project_id => 1)
                   Issue.generate!(:assigned_to => User.find(2), :due_date => 5.days.from_now)
                   Issue.generate!(:assigned_to => User.find(3), :due_date => 5.days.from_now, :fixed_version => version)
                   ActionMailer::Base.deliveries.clear
                   Mailer.reminders(:days => 42, :version => 'acme')
                   assert_equal 1, ActionMailer::Base.deliveries.size
                   mail = last_email
                   assert mail.bcc.include?('dlopper@somenet.foo')
                 end
               end
               def test_mailer_should_not_change_locale
                 # 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.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.test_email(User.find(1)).deliver
                 end
                 assert ActionMailer::Base.deliveries.empty?
                 # should restore perform_deliveries
                 assert ActionMailer::Base.perform_deliveries
               end
               def test_token_for_should_strip_trailing_gt_from_address_with_full_name
                 with_settings :mail_from => "Redmine Mailer<no-reply@redmine.org>" do
                   assert_match /\Aredmine.issue-\d+\.\d+\.[0-9a-f]+@redmine.org\z/, Mailer.token_for(Issue.generate!)
                 end
               end
               def test_layout_should_include_the_emails_header
                 with_settings :emails_header => "*Header content*" do
                   with_settings :plain_text_mail => 0 do
                     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
                   with_settings :plain_text_mail => 1 do
                     assert Mailer.test_email(User.find(1)).deliver
                     mail = last_email
                     assert_not_nil mail
                     assert_include "*Header content*", mail.body.decoded
                   end
                 end
               end
               def test_layout_should_not_include_empty_emails_header
                 with_settings :emails_header => "", :plain_text_mail => 0 do
                   assert Mailer.test_email(User.find(1)).deliver
                   assert_select_email do
                     assert_select ".header", false
                   end
                 end
               end
               def test_layout_should_include_the_emails_footer
                 with_settings :emails_footer => "*Footer content*" do
                   with_settings :plain_text_mail => 0 do
                     assert Mailer.test_email(User.find(1)).deliver
                     assert_select_email do
                       assert_select ".footer" do
                         assert_select "strong", :text => "Footer content"
                       end
                     end
                   end
                   with_settings :plain_text_mail => 1 do
                     assert Mailer.test_email(User.find(1)).deliver
                     mail = last_email
                     assert_not_nil mail
                     assert_include "\n-- \n", mail.body.decoded
                     assert_include "*Footer content*", mail.body.decoded
                   end
                 end
               end
               def test_layout_should_not_include_empty_emails_footer
                 with_settings :emails_footer => "" do
                   with_settings :plain_text_mail => 0 do
                     assert Mailer.test_email(User.find(1)).deliver
                     assert_select_email do
                       assert_select ".footer", false
                     end
                   end
                   with_settings :plain_text_mail => 1 do
                     assert Mailer.test_email(User.find(1)).deliver
                     mail = last_email
                     assert_not_nil mail
                     assert_not_include "\n-- \n", mail.body.decoded
                   end
                 end
               end
               def test_should_escape_html_templates_only
                 Issue.generate!(:project_id => 1, :tracker_id => 1, :subject => 'Subject with a <tag>')
                 mail = last_email
                 assert_equal 2, mail.parts.size
                 assert_include '<tag>', text_part.body.encoded
                 assert_include '&lt;tag&gt;', html_part.body.encoded
               end
               def test_should_raise_delivery_errors_when_raise_delivery_errors_is_true
                 mail = Mailer.test_email(User.find(1))
                 mail.delivery_method.stubs(:deliver!).raises(Exception.new("delivery error"))
                 ActionMailer::Base.raise_delivery_errors = true
                 assert_raise Exception, "delivery error" do
                   mail.deliver
                 end
               ensure
                 ActionMailer::Base.raise_delivery_errors = false
               end
               def test_should_log_delivery_errors_when_raise_delivery_errors_is_false
                 mail = Mailer.test_email(User.find(1))
                 mail.delivery_method.stubs(:deliver!).raises(Exception.new("delivery error"))
                 Rails.logger.expects(:error).with("Email delivery error: delivery error")
                 ActionMailer::Base.raise_delivery_errors = false
                 assert_nothing_raised do
                   mail.deliver
                 end
               end
               def test_with_synched_deliveries_should_yield_with_synced_deliveries
                 ActionMailer::Base.delivery_method = :async_smtp
                 ActionMailer::Base.async_smtp_settings = {:foo => 'bar'}
                 Mailer.with_synched_deliveries do
                   assert_equal :smtp, ActionMailer::Base.delivery_method
                   assert_equal({:foo => 'bar'}, ActionMailer::Base.smtp_settings)
                 end
                 assert_equal :async_smtp, ActionMailer::Base.delivery_method
               ensure
                 ActionMailer::Base.delivery_method = :test
               end
               def test_email_addresses_should_keep_addresses
                 assert_equal ["foo@example.net"],
                   Mailer.email_addresses("foo@example.net")
                 assert_equal ["foo@example.net", "bar@example.net"],
                   Mailer.email_addresses(["foo@example.net", "bar@example.net"])
               end
               def test_email_addresses_should_replace_users_with_their_email_addresses
                 assert_equal ["admin@somenet.foo"],
                   Mailer.email_addresses(User.find(1))
                 assert_equal ["admin@somenet.foo", "jsmith@somenet.foo"],
                   Mailer.email_addresses(User.where(:id => [1,2])).sort
               end
               def test_email_addresses_should_include_notified_emails_addresses_only
                 EmailAddress.create!(:user_id => 2, :address => "another@somenet.foo", :notify => false)
                 EmailAddress.create!(:user_id => 2, :address => "another2@somenet.foo")
                 assert_equal ["another2@somenet.foo", "jsmith@somenet.foo"],
                   Mailer.email_addresses(User.find(2)).sort
               end
               private
               def last_email
                 mail = ActionMailer::Base.deliveries.last
                 assert_not_nil mail
                 mail
               end
               def text_part
                 last_email.parts.detect {|part| part.content_type.include?('text/plain')}
               end
               def html_part
                 last_email.parts.detect {|part| part.content_type.include?('text/html')}
               end
               def with_each_language_as_default(&block)
                 valid_languages.each do |lang|
                   with_settings :default_language => lang.to_s do
                     yield lang
                   end
                 end
               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