jro_apps/redmine Commit - r11001:ed7318fb8d74

Backported r11157 and r11158 from trunk (#12801)....

Jean-Philippe Lang -

r11001:ed7318fb8d74

parent child

Context file:

r11001:ed7318fb8d74

Collapse all files

app/helpers/application_helper.rb +3 -2

             # encoding: utf-8
             #
             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require 'forwardable'
             require 'cgi'
             module ApplicationHelper
               include Redmine::WikiFormatting::Macros::Definitions
               include Redmine::I18n
               include GravatarHelper::PublicMethods
               extend Forwardable
               def_delegators :wiki_helper, :wikitoolbar_for, :heads_for_wiki_formatter
               # Return true if user is authorized for controller/action, otherwise false
               def authorize_for(controller, action)
                 User.current.allowed_to?({:controller => controller, :action => action}, @project)
               end
               # Display a link if user is authorized
               #
               # @param [String] name Anchor text (passed to link_to)
               # @param [Hash] options Hash params. This will checked by authorize_for to see if the user is authorized
               # @param [optional, Hash] html_options Options passed to link_to
               # @param [optional, Hash] parameters_for_method_reference Extra parameters for link_to
               def link_to_if_authorized(name, options = {}, html_options = nil, *parameters_for_method_reference)
                 link_to(name, options, html_options, *parameters_for_method_reference) if authorize_for(options[:controller] || params[:controller], options[:action])
               end
               # Displays a link to user's account page if active
               def link_to_user(user, options={})
                 if user.is_a?(User)
                   name = h(user.name(options[:format]))
                   if user.active? || (User.current.admin? && user.logged?)
                     link_to name, user_path(user), :class => user.css_classes
                   else
                     name
                   end
                 else
                   h(user.to_s)
                 end
               end
               # Displays a link to +issue+ with its subject.
               # Examples:
               #
               #   link_to_issue(issue)                        # => Defect #6: This is the subject
               #   link_to_issue(issue, :truncate => 6)        # => Defect #6: This i...
               #   link_to_issue(issue, :subject => false)     # => Defect #6
               #   link_to_issue(issue, :project => true)      # => Foo - Defect #6
               #   link_to_issue(issue, :subject => false, :tracker => false)     # => #6
               #
               def link_to_issue(issue, options={})
                 title = nil
                 subject = nil
                 text = options[:tracker] == false ? "##{issue.id}" : "#{issue.tracker} ##{issue.id}"
                 if options[:subject] == false
                   title = truncate(issue.subject, :length => 60)
                 else
                   subject = issue.subject
                   if options[:truncate]
                     subject = truncate(subject, :length => options[:truncate])
                   end
                 end
                 s = link_to text, issue_path(issue), :class => issue.css_classes, :title => title
                 s << h(": #{subject}") if subject
                 s = h("#{issue.project} - ") + s if options[:project]
                 s
               end
               # Generates a link to an attachment.
               # Options:
               # * :text - Link text (default to attachment filename)
               # * :download - Force download (default: false)
               def link_to_attachment(attachment, options={})
                 text = options.delete(:text) || attachment.filename
                 action = options.delete(:download) ? 'download' : 'show'
                 opt_only_path = {}
                 opt_only_path[:only_path] = (options[:only_path] == false ? false : true)
                 options.delete(:only_path)
                 link_to(h(text),
                        {:controller => 'attachments', :action => action,
                         :id => attachment, :filename => attachment.filename}.merge(opt_only_path),
                        options)
               end
               # Generates a link to a SCM revision
               # Options:
               # * :text - Link text (default to the formatted revision)
               def link_to_revision(revision, repository, options={})
                 if repository.is_a?(Project)
                   repository = repository.repository
                 end
                 text = options.delete(:text) || format_revision(revision)
                 rev = revision.respond_to?(:identifier) ? revision.identifier : revision
                 link_to(
                     h(text),
                     {:controller => 'repositories', :action => 'revision', :id => repository.project, :repository_id => repository.identifier_param, :rev => rev},
                     :title => l(:label_revision_id, format_revision(revision))
                   )
               end
               # Generates a link to a message
               def link_to_message(message, options={}, html_options = nil)
                 link_to(
                   h(truncate(message.subject, :length => 60)),
                   { :controller => 'messages', :action => 'show',
                     :board_id => message.board_id,
                     :id => (message.parent_id || message.id),
                     :r => (message.parent_id && message.id),
                     :anchor => (message.parent_id ? "message-#{message.id}" : nil)
                   }.merge(options),
                   html_options
                 )
               end
               # Generates a link to a project if active
               # Examples:
               #
               #   link_to_project(project)                          # => link to the specified project overview
               #   link_to_project(project, :action=>'settings')     # => link to project settings
               #   link_to_project(project, {:only_path => false}, :class => "project") # => 3rd arg adds html options
               #   link_to_project(project, {}, :class => "project") # => html options with default url (project overview)
               #
               def link_to_project(project, options={}, html_options = nil)
                 if project.archived?
                   h(project)
                 else
                   url = {:controller => 'projects', :action => 'show', :id => project}.merge(options)
                   link_to(h(project), url, html_options)
                 end
               end
               def wiki_page_path(page, options={})
                 url_for({:controller => 'wiki', :action => 'show', :project_id => page.project, :id => page.title}.merge(options))
               end
               def thumbnail_tag(attachment)
                 link_to image_tag(url_for(:controller => 'attachments', :action => 'thumbnail', :id => attachment)),
                   {:controller => 'attachments', :action => 'show', :id => attachment, :filename => attachment.filename},
                   :title => attachment.filename
               end
               def toggle_link(name, id, options={})
                 onclick = "$('##{id}').toggle(); "
                 onclick << (options[:focus] ? "$('##{options[:focus]}').focus(); " : "this.blur(); ")
                 onclick << "return false;"
                 link_to(name, "#", :onclick => onclick)
               end
               def image_to_function(name, function, html_options = {})
                 html_options.symbolize_keys!
                 tag(:input, html_options.merge({
                     :type => "image", :src => image_path(name),
                     :onclick => (html_options[:onclick] ? "#{html_options[:onclick]}; " : "") + "#{function};"
                     }))
               end
               def format_activity_title(text)
                 h(truncate_single_line(text, :length => 100))
               end
               def format_activity_day(date)
                 date == User.current.today ? l(:label_today).titleize : format_date(date)
               end
               def format_activity_description(text)
                 h(truncate(text.to_s, :length => 120).gsub(%r{[\r\n]*<(pre|code)>.*$}m, '...')
                    ).gsub(/[\r\n]+/, "<br />").html_safe
               end
               def format_version_name(version)
                 if version.project == @project
                 	h(version)
                 else
                   h("#{version.project} - #{version}")
                 end
               end
               def due_date_distance_in_words(date)
                 if date
                   l((date < Date.today ? :label_roadmap_overdue : :label_roadmap_due_in), distance_of_date_in_words(Date.today, date))
                 end
               end
               # Renders a tree of projects as a nested set of unordered lists
               # The given collection may be a subset of the whole project tree
               # (eg. some intermediate nodes are private and can not be seen)
               def render_project_nested_lists(projects)
                 s = ''
                 if projects.any?
                   ancestors = []
                   original_project = @project
                   projects.sort_by(&:lft).each do |project|
                     # set the project environment to please macros.
                     @project = project
                     if (ancestors.empty? || project.is_descendant_of?(ancestors.last))
                       s << "<ul class='projects #{ ancestors.empty? ? 'root' : nil}'>\n"
                     else
                       ancestors.pop
                       s << "</li>"
                       while (ancestors.any? && !project.is_descendant_of?(ancestors.last))
                         ancestors.pop
                         s << "</ul></li>\n"
                       end
                     end
                     classes = (ancestors.empty? ? 'root' : 'child')
                     s << "<li class='#{classes}'><div class='#{classes}'>"
                     s << h(block_given? ? yield(project) : project.name)
                     s << "</div>\n"
                     ancestors << project
                   end
                   s << ("</li></ul>\n" * ancestors.size)
                   @project = original_project
                 end
                 s.html_safe
               end
               def render_page_hierarchy(pages, node=nil, options={})
                 content = ''
                 if pages[node]
                   content << "<ul class=\"pages-hierarchy\">\n"
                   pages[node].each do |page|
                     content << "<li>"
                     content << link_to(h(page.pretty_title), {:controller => 'wiki', :action => 'show', :project_id => page.project, :id => page.title, :version => nil},
                                        :title => (options[:timestamp] && page.updated_on ? l(:label_updated_time, distance_of_time_in_words(Time.now, page.updated_on)) : nil))
                     content << "\n" + render_page_hierarchy(pages, page.id, options) if pages[page.id]
                     content << "</li>\n"
                   end
                   content << "</ul>\n"
                 end
                 content.html_safe
               end
               # Renders flash messages
               def render_flash_messages
                 s = ''
                 flash.each do |k,v|
                   s << content_tag('div', v.html_safe, :class => "flash #{k}", :id => "flash_#{k}")
                 end
                 s.html_safe
               end
               # Renders tabs and their content
               def render_tabs(tabs)
                 if tabs.any?
                   render :partial => 'common/tabs', :locals => {:tabs => tabs}
                 else
                   content_tag 'p', l(:label_no_data), :class => "nodata"
                 end
               end
               # Renders the project quick-jump box
               def render_project_jump_box
                 return unless User.current.logged?
                 projects = User.current.memberships.collect(&:project).compact.select(&:active?).uniq
                 if projects.any?
                   options =
                     ("<option value=''>#{ l(:label_jump_to_a_project) }</option>" +
                      '<option value="" disabled="disabled">---</option>').html_safe
                   options << project_tree_options_for_select(projects, :selected => @project) do |p|
                     { :value => project_path(:id => p, :jump => current_menu_item) }
                   end
                   select_tag('project_quick_jump_box', options, :onchange => 'if (this.value != \'\') { window.location = this.value; }')
                 end
               end
               def project_tree_options_for_select(projects, options = {})
                 s = ''
                 project_tree(projects) do |project, level|
                   name_prefix = (level > 0 ? '&nbsp;' * 2 * level + '&#187; ' : '').html_safe
                   tag_options = {:value => project.id}
                   if project == options[:selected] || (options[:selected].respond_to?(:include?) && options[:selected].include?(project))
                     tag_options[:selected] = 'selected'
                   else
                     tag_options[:selected] = nil
                   end
                   tag_options.merge!(yield(project)) if block_given?
                   s << content_tag('option', name_prefix + h(project), tag_options)
                 end
                 s.html_safe
               end
               # Yields the given block for each project with its level in the tree
               #
               # Wrapper for Project#project_tree
               def project_tree(projects, &block)
                 Project.project_tree(projects, &block)
               end
               def principals_check_box_tags(name, principals)
                 s = ''
                 principals.sort.each do |principal|
                   s << "<label>#{ check_box_tag name, principal.id, false } #{h principal}</label>\n"
                 end
                 s.html_safe
               end
               # Returns a string for users/groups option tags
               def principals_options_for_select(collection, selected=nil)
                 s = ''
                 if collection.include?(User.current)
                   s << content_tag('option', "<< #{l(:label_me)} >>", :value => User.current.id)
                 end
                 groups = ''
                 collection.sort.each do |element|
                   selected_attribute = ' selected="selected"' if option_value_selected?(element, selected)
                   (element.is_a?(Group) ? groups : s) << %(<option value="#{element.id}"#{selected_attribute}>#{h element.name}</option>)
                 end
                 unless groups.empty?
                   s << %(<optgroup label="#{h(l(:label_group_plural))}">#{groups}</optgroup>)
                 end
                 s.html_safe
               end
               # Options for the new membership projects combo-box
               def options_for_membership_project_select(principal, projects)
                 options = content_tag('option', "--- #{l(:actionview_instancetag_blank_option)} ---")
                 options << project_tree_options_for_select(projects) do |p|
                   {:disabled => principal.projects.include?(p)}
                 end
                 options
               end
               # Truncates and returns the string as a single line
               def truncate_single_line(string, *args)
                 truncate(string.to_s, *args).gsub(%r{[\r\n]+}m, ' ')
               end
               # Truncates at line break after 250 characters or options[:length]
               def truncate_lines(string, options={})
                 length = options[:length] || 250
                 if string.to_s =~ /\A(.{#{length}}.*?)$/m
                   "#{$1}..."
                 else
                   string
                 end
               end
               def anchor(text)
                 text.to_s.gsub(' ', '_')
               end
               def html_hours(text)
                 text.gsub(%r{(\d+)\.(\d+)}, '<span class="hours hours-int">\1</span><span class="hours hours-dec">.\2</span>').html_safe
               end
               def authoring(created, author, options={})
                 l(options[:label] || :label_added_time_by, :author => link_to_user(author), :age => time_tag(created)).html_safe
               end
               def time_tag(time)
                 text = distance_of_time_in_words(Time.now, time)
                 if @project
                   link_to(text, {:controller => 'activities', :action => 'index', :id => @project, :from => User.current.time_to_date(time)}, :title => format_time(time))
                 else
                   content_tag('acronym', text, :title => format_time(time))
                 end
               end
               def syntax_highlight_lines(name, content)
                 lines = []
                 syntax_highlight(name, content).each_line { |line| lines << line }
                 lines
               end
               def syntax_highlight(name, content)
                 Redmine::SyntaxHighlighting.highlight_by_filename(content, name)
               end
               def to_path_param(path)
                 str = path.to_s.split(%r{[/\\]}).select{|p| !p.blank?}.join("/")
                 str.blank? ? nil : str
               end
               def pagination_links_full(paginator, count=nil, options={})
                 page_param = options.delete(:page_param) || :page
                 per_page_links = options.delete(:per_page_links)
                 url_param = params.dup
                 html = ''
                 if paginator.current.previous
                   # \xc2\xab(utf-8) = &#171;
                   html << link_to_content_update(
                                "\xc2\xab " + l(:label_previous),
                                url_param.merge(page_param => paginator.current.previous)) + ' '
                 end
                 html << (pagination_links_each(paginator, options) do |n|
                   link_to_content_update(n.to_s, url_param.merge(page_param => n))
                 end || '')
                 if paginator.current.next
                   # \xc2\xbb(utf-8) = &#187;
                   html << ' ' + link_to_content_update(
                                   (l(:label_next) + " \xc2\xbb"),
                                   url_param.merge(page_param => paginator.current.next))
                 end
                 unless count.nil?
                   html << " (#{paginator.current.first_item}-#{paginator.current.last_item}/#{count})"
                   if per_page_links != false && links = per_page_links(paginator.items_per_page, count)
             	      html << " | #{links}"
                   end
                 end
                 html.html_safe
               end
               def per_page_links(selected=nil, item_count=nil)
                 values = Setting.per_page_options_array
                 if item_count && values.any?
                   if item_count > values.first
                     max = values.detect {|value| value >= item_count} || item_count
                   else
                     max = item_count
                   end
                   values = values.select {|value| value <= max || value == selected}
                 end
                 if values.empty? || (values.size == 1 && values.first == selected)
                   return nil
                 end
                 links = values.collect do |n|
                   n == selected ? n : link_to_content_update(n, params.merge(:per_page => n))
                 end
                 l(:label_display_per_page, links.join(', '))
               end
               def reorder_links(name, url, method = :post)
                 link_to(image_tag('2uparrow.png', :alt => l(:label_sort_highest)),
                         url.merge({"#{name}[move_to]" => 'highest'}),
                         :method => method, :title => l(:label_sort_highest)) +
                 link_to(image_tag('1uparrow.png',   :alt => l(:label_sort_higher)),
                         url.merge({"#{name}[move_to]" => 'higher'}),
                        :method => method, :title => l(:label_sort_higher)) +
                 link_to(image_tag('1downarrow.png', :alt => l(:label_sort_lower)),
                         url.merge({"#{name}[move_to]" => 'lower'}),
                         :method => method, :title => l(:label_sort_lower)) +
                 link_to(image_tag('2downarrow.png', :alt => l(:label_sort_lowest)),
                         url.merge({"#{name}[move_to]" => 'lowest'}),
                        :method => method, :title => l(:label_sort_lowest))
               end
               def breadcrumb(*args)
                 elements = args.flatten
                 elements.any? ? content_tag('p', (args.join(" \xc2\xbb ") + " \xc2\xbb ").html_safe, :class => 'breadcrumb') : nil
               end
               def other_formats_links(&block)
                 concat('<p class="other-formats">'.html_safe + l(:label_export_to))
                 yield Redmine::Views::OtherFormatsBuilder.new(self)
                 concat('</p>'.html_safe)
               end
               def page_header_title
                 if @project.nil? || @project.new_record?
                   h(Setting.app_title)
                 else
                   b = []
                   ancestors = (@project.root? ? [] : @project.ancestors.visible.all)
                   if ancestors.any?
                     root = ancestors.shift
                     b << link_to_project(root, {:jump => current_menu_item}, :class => 'root')
                     if ancestors.size > 2
                       b << "\xe2\x80\xa6"
                       ancestors = ancestors[-2, 2]
                     end
                     b += ancestors.collect {|p| link_to_project(p, {:jump => current_menu_item}, :class => 'ancestor') }
                   end
                   b << h(@project)
                   b.join(" \xc2\xbb ").html_safe
                 end
               end
               def html_title(*args)
                 if args.empty?
                   title = @html_title || []
                   title << @project.name if @project
                   title << Setting.app_title unless Setting.app_title == title.last
                   title.select {|t| !t.blank? }.join(' - ')
                 else
                   @html_title ||= []
                   @html_title += args
                 end
               end
               # Returns the theme, controller name, and action as css classes for the
               # HTML body.
               def body_css_classes
                 css = []
                 if theme = Redmine::Themes.theme(Setting.ui_theme)
                   css << 'theme-' + theme.name
                 end
                 css << 'controller-' + controller_name
                 css << 'action-' + action_name
                 css.join(' ')
               end
               def accesskey(s)
                 Redmine::AccessKeys.key_for s
               end
               # Formats text according to system settings.
               # 2 ways to call this method:
               # * with a String: textilizable(text, options)
               # * with an object and one of its attribute: textilizable(issue, :description, options)
               def textilizable(*args)
                 options = args.last.is_a?(Hash) ? args.pop : {}
                 case args.size
                 when 1
                   obj = options[:object]
                   text = args.shift
                 when 2
                   obj = args.shift
                   attr = args.shift
                   text = obj.send(attr).to_s
                 else
                   raise ArgumentError, 'invalid arguments to textilizable'
                 end
                 return '' if text.blank?
                 project = options[:project] || @project || (obj && obj.respond_to?(:project) ? obj.project : nil)
                 only_path = options.delete(:only_path) == false ? false : true
                 text = text.dup
                 macros = catch_macros(text)
                 text = Redmine::WikiFormatting.to_html(Setting.text_formatting, text, :object => obj, :attribute => attr)
                 @parsed_headings = []
                 @heading_anchors = {}
                 @current_section = 0 if options[:edit_section_links]
                 parse_sections(text, project, obj, attr, only_path, options)
                 text = parse_non_pre_blocks(text, obj, macros) do |text|
                   [:parse_inline_attachments, :parse_wiki_links, :parse_redmine_links].each do |method_name|
                     send method_name, text, project, obj, attr, only_path, options
                   end
                 end
                 parse_headings(text, project, obj, attr, only_path, options)
                 if @parsed_headings.any?
                   replace_toc(text, @parsed_headings)
                 end
                 text.html_safe
               end
               def parse_non_pre_blocks(text, obj, macros)
                 s = StringScanner.new(text)
                 tags = []
                 parsed = ''
                 while !s.eos?
                   s.scan(/(.*?)(<(\/)?(pre|code)(.*?)>|\z)/im)
                   text, full_tag, closing, tag = s[1], s[2], s[3], s[4]
                   if tags.empty?
                     yield text
                     inject_macros(text, obj, macros) if macros.any?
                   else
                     inject_macros(text, obj, macros, false) if macros.any?
                   end
                   parsed << text
                   if tag
                     if closing
                       if tags.last == tag.downcase
                         tags.pop
                       end
                     else
                       tags << tag.downcase
                     end
                     parsed << full_tag
                   end
                 end
                 # Close any non closing tags
                 while tag = tags.pop
                   parsed << "</#{tag}>"
                 end
                 parsed
               end
               def parse_inline_attachments(text, project, obj, attr, only_path, options)
                 # when using an image link, try to use an attachment, if possible
-                if options[:attachments] || (obj && obj.respond_to?(:attachments))
+                attachments = options[:attachments] || []
-                  attachments = options[:attachments] || obj.attachments
+                attachments += obj.attachments if obj.respond_to?(:attachments)
+                if attachments.present?
                   text.gsub!(/src="([^\/"]+\.(bmp|gif|jpg|jpe|jpeg|png))"(\s+alt="([^"]*)")?/i) do |m|
                     filename, ext, alt, alttext = $1.downcase, $2, $3, $4
                     # search for the picture in attachments
                     if found = Attachment.latest_attach(attachments, filename)
                       image_url = url_for :only_path => only_path, :controller => 'attachments',
                                           :action => 'download', :id => found
                       desc = found.description.to_s.gsub('"', '')
                       if !desc.blank? && alttext.blank?
                         alt = " title=\"#{desc}\" alt=\"#{desc}\""
                       end
                       "src=\"#{image_url}\"#{alt}"
                     else
                       m
                     end
                   end
                 end
               end
               # Wiki links
               #
               # Examples:
               #   [[mypage]]
               #   [[mypage|mytext]]
               # wiki links can refer other project wikis, using project name or identifier:
               #   [[project:]] -> wiki starting page
               #   [[project:|mytext]]
               #   [[project:mypage]]
               #   [[project:mypage|mytext]]
               def parse_wiki_links(text, project, obj, attr, only_path, options)
                 text.gsub!(/(!)?(\[\[([^\]\n\|]+)(\|([^\]\n\|]+))?\]\])/) do |m|
                   link_project = project
                   esc, all, page, title = $1, $2, $3, $5
                   if esc.nil?
                     if page =~ /^([^\:]+)\:(.*)$/
                       link_project = Project.find_by_identifier($1) || Project.find_by_name($1)
                       page = $2
                       title ||= $1 if page.blank?
                     end
                     if link_project && link_project.wiki
                       # extract anchor
                       anchor = nil
                       if page =~ /^(.+?)\#(.+)$/
                         page, anchor = $1, $2
                       end
                       anchor = sanitize_anchor_name(anchor) if anchor.present?
                       # check if page exists
                       wiki_page = link_project.wiki.find_page(page)
                       url = if anchor.present? && wiki_page.present? && (obj.is_a?(WikiContent) || obj.is_a?(WikiContent::Version)) && obj.page == wiki_page
                         "##{anchor}"
                       else
                         case options[:wiki_links]
                         when :local; "#{page.present? ? Wiki.titleize(page) : ''}.html" + (anchor.present? ? "##{anchor}" : '')
                         when :anchor; "##{page.present? ? Wiki.titleize(page) : title}" + (anchor.present? ? "_#{anchor}" : '') # used for single-file wiki export
                         else
                           wiki_page_id = page.present? ? Wiki.titleize(page) : nil
                           parent = wiki_page.nil? && obj.is_a?(WikiContent) && obj.page && project == link_project ? obj.page.title : nil
                           url_for(:only_path => only_path, :controller => 'wiki', :action => 'show', :project_id => link_project,
                            :id => wiki_page_id, :version => nil, :anchor => anchor, :parent => parent)
                         end
                       end
                       link_to(title.present? ? title.html_safe : h(page), url, :class => ('wiki-page' + (wiki_page ? '' : ' new')))
                     else
                       # project or wiki doesn't exist
                       all
                     end
                   else
                     all
                   end
                 end
               end
               # Redmine links
               #
               # Examples:
               #   Issues:
               #     #52 -> Link to issue #52
               #   Changesets:
               #     r52 -> Link to revision 52
               #     commit:a85130f -> Link to scmid starting with a85130f
               #   Documents:
               #     document#17 -> Link to document with id 17
               #     document:Greetings -> Link to the document with title "Greetings"
               #     document:"Some document" -> Link to the document with title "Some document"
               #   Versions:
               #     version#3 -> Link to version with id 3
               #     version:1.0.0 -> Link to version named "1.0.0"
               #     version:"1.0 beta 2" -> Link to version named "1.0 beta 2"
               #   Attachments:
               #     attachment:file.zip -> Link to the attachment of the current object named file.zip
               #   Source files:
               #     source:some/file -> Link to the file located at /some/file in the project's repository
               #     source:some/file@52 -> Link to the file's revision 52
               #     source:some/file#L120 -> Link to line 120 of the file
               #     source:some/file@52#L120 -> Link to line 120 of the file's revision 52
               #     export:some/file -> Force the download of the file
               #   Forum messages:
               #     message#1218 -> Link to message with id 1218
               #
               #   Links can refer other objects from other projects, using project identifier:
               #     identifier:r52
               #     identifier:document:"Some document"
               #     identifier:version:1.0.0
               #     identifier:source:some/file
               def parse_redmine_links(text, project, obj, attr, only_path, options)
                 text.gsub!(%r{([\s\(,\-\[\>]|^)(!)?(([a-z0-9\-_]+):)?(attachment|document|version|forum|news|message|project|commit|source|export)?(((#)|((([a-z0-9\-]+)\|)?(r)))((\d+)((#note)?-(\d+))?)|(:)([^"\s<>][^\s<>]*?|"[^"]+?"))(?=(?=[[:punct:]][^A-Za-z0-9_/])|,|\s|\]|<|$)}) do |m|
                   leading, esc, project_prefix, project_identifier, prefix, repo_prefix, repo_identifier, sep, identifier, comment_suffix, comment_id = $1, $2, $3, $4, $5, $10, $11, $8 || $12 || $18, $14 || $19, $15, $17
                   link = nil
                   if project_identifier
                     project = Project.visible.find_by_identifier(project_identifier)
                   end
                   if esc.nil?
                     if prefix.nil? && sep == 'r'
                       if project
                         repository = nil
                         if repo_identifier
                           repository = project.repositories.detect {|repo| repo.identifier == repo_identifier}
                         else
                           repository = project.repository
                         end
                         # project.changesets.visible raises an SQL error because of a double join on repositories
                         if repository && (changeset = Changeset.visible.find_by_repository_id_and_revision(repository.id, identifier))
                           link = link_to(h("#{project_prefix}#{repo_prefix}r#{identifier}"), {:only_path => only_path, :controller => 'repositories', :action => 'revision', :id => project, :repository_id => repository.identifier_param, :rev => changeset.revision},
                                                     :class => 'changeset',
                                                     :title => truncate_single_line(changeset.comments, :length => 100))
                         end
                       end
                     elsif sep == '#'
                       oid = identifier.to_i
                       case prefix
                       when nil
                         if oid.to_s == identifier && issue = Issue.visible.find_by_id(oid, :include => :status)
                           anchor = comment_id ? "note-#{comment_id}" : nil
                           link = link_to("##{oid}", {:only_path => only_path, :controller => 'issues', :action => 'show', :id => oid, :anchor => anchor},
                                                     :class => issue.css_classes,
                                                     :title => "#{truncate(issue.subject, :length => 100)} (#{issue.status.name})")
                         end
                       when 'document'
                         if document = Document.visible.find_by_id(oid)
                           link = link_to h(document.title), {:only_path => only_path, :controller => 'documents', :action => 'show', :id => document},
                                                             :class => 'document'
                         end
                       when 'version'
                         if version = Version.visible.find_by_id(oid)
                           link = link_to h(version.name), {:only_path => only_path, :controller => 'versions', :action => 'show', :id => version},
                                                           :class => 'version'
                         end
                       when 'message'
                         if message = Message.visible.find_by_id(oid, :include => :parent)
                           link = link_to_message(message, {:only_path => only_path}, :class => 'message')
                         end
                       when 'forum'
                         if board = Board.visible.find_by_id(oid)
                           link = link_to h(board.name), {:only_path => only_path, :controller => 'boards', :action => 'show', :id => board, :project_id => board.project},
                                                          :class => 'board'
                         end
                       when 'news'
                         if news = News.visible.find_by_id(oid)
                           link = link_to h(news.title), {:only_path => only_path, :controller => 'news', :action => 'show', :id => news},
                                                         :class => 'news'
                         end
                       when 'project'
                         if p = Project.visible.find_by_id(oid)
                           link = link_to_project(p, {:only_path => only_path}, :class => 'project')
                         end
                       end
                     elsif sep == ':'
                       # removes the double quotes if any
                       name = identifier.gsub(%r{^"(.*)"$}, "\\1")
                       case prefix
                       when 'document'
                         if project && document = project.documents.visible.find_by_title(name)
                           link = link_to h(document.title), {:only_path => only_path, :controller => 'documents', :action => 'show', :id => document},
                                                             :class => 'document'
                         end
                       when 'version'
                         if project && version = project.versions.visible.find_by_name(name)
                           link = link_to h(version.name), {:only_path => only_path, :controller => 'versions', :action => 'show', :id => version},
                                                           :class => 'version'
                         end
                       when 'forum'
                         if project && board = project.boards.visible.find_by_name(name)
                           link = link_to h(board.name), {:only_path => only_path, :controller => 'boards', :action => 'show', :id => board, :project_id => board.project},
                                                          :class => 'board'
                         end
                       when 'news'
                         if project && news = project.news.visible.find_by_title(name)
                           link = link_to h(news.title), {:only_path => only_path, :controller => 'news', :action => 'show', :id => news},
                                                         :class => 'news'
                         end
                       when 'commit', 'source', 'export'
                         if project
                           repository = nil
                           if name =~ %r{^(([a-z0-9\-]+)\|)(.+)$}
                             repo_prefix, repo_identifier, name = $1, $2, $3
                             repository = project.repositories.detect {|repo| repo.identifier == repo_identifier}
                           else
                             repository = project.repository
                           end
                           if prefix == 'commit'
                             if repository && (changeset = Changeset.visible.find(:first, :conditions => ["repository_id = ? AND scmid LIKE ?", repository.id, "#{name}%"]))
                               link = link_to h("#{project_prefix}#{repo_prefix}#{name}"), {:only_path => only_path, :controller => 'repositories', :action => 'revision', :id => project, :repository_id => repository.identifier_param, :rev => changeset.identifier},
                                                            :class => 'changeset',
                                                            :title => truncate_single_line(h(changeset.comments), :length => 100)
                             end
                           else
                             if repository && User.current.allowed_to?(:browse_repository, project)
                               name =~ %r{^[/\\]*(.*?)(@([0-9a-f]+))?(#(L\d+))?$}
                               path, rev, anchor = $1, $3, $5
                               link = link_to h("#{project_prefix}#{prefix}:#{repo_prefix}#{name}"), {:controller => 'repositories', :action => (prefix == 'export' ? 'raw' : 'entry'), :id => project, :repository_id => repository.identifier_param,
                                                                       :path => to_path_param(path),
                                                                       :rev => rev,
                                                                       :anchor => anchor},
                                                                      :class => (prefix == 'export' ? 'source download' : 'source')
                             end
                           end
                           repo_prefix = nil
                         end
                       when 'attachment'
                         attachments = options[:attachments] || (obj && obj.respond_to?(:attachments) ? obj.attachments : nil)
                         if attachments && attachment = Attachment.latest_attach(attachments, name)
                           link = link_to h(attachment.filename), {:only_path => only_path, :controller => 'attachments', :action => 'download', :id => attachment},
                                                                  :class => 'attachment'
                         end
                       when 'project'
                         if p = Project.visible.find(:first, :conditions => ["identifier = :s OR LOWER(name) = :s", {:s => name.downcase}])
                           link = link_to_project(p, {:only_path => only_path}, :class => 'project')
                         end
                       end
                     end
                   end
                   (leading + (link || "#{project_prefix}#{prefix}#{repo_prefix}#{sep}#{identifier}#{comment_suffix}"))
                 end
               end
               HEADING_RE = /(<h(\d)( [^>]+)?>(.+?)<\/h(\d)>)/i unless const_defined?(:HEADING_RE)
               def parse_sections(text, project, obj, attr, only_path, options)
                 return unless options[:edit_section_links]
                 text.gsub!(HEADING_RE) do
                   heading = $1
                   @current_section += 1
                   if @current_section > 1
                     content_tag('div',
                       link_to(image_tag('edit.png'), options[:edit_section_links].merge(:section => @current_section)),
                       :class => 'contextual',
                       :title => l(:button_edit_section)) + heading.html_safe
                   else
                     heading
                   end
                 end
               end
               # Headings and TOC
               # Adds ids and links to headings unless options[:headings] is set to false
               def parse_headings(text, project, obj, attr, only_path, options)
                 return if options[:headings] == false
                 text.gsub!(HEADING_RE) do
                   level, attrs, content = $2.to_i, $3, $4
                   item = strip_tags(content).strip
                   anchor = sanitize_anchor_name(item)
                   # used for single-file wiki export
                   anchor = "#{obj.page.title}_#{anchor}" if options[:wiki_links] == :anchor && (obj.is_a?(WikiContent) || obj.is_a?(WikiContent::Version))
                   @heading_anchors[anchor] ||= 0
                   idx = (@heading_anchors[anchor] += 1)
                   if idx > 1
                     anchor = "#{anchor}-#{idx}"
                   end
                   @parsed_headings << [level, anchor, item]
                   "<a name=\"#{anchor}\"></a>\n<h#{level} #{attrs}>#{content}<a href=\"##{anchor}\" class=\"wiki-anchor\">&para;</a></h#{level}>"
                 end
               end
               MACROS_RE = /(
                             (!)?                        # escaping
                             (
                             \{\{                        # opening tag
                             ([\w]+)                     # macro name
                             (\(([^\n\r]*?)\))?          # optional arguments
                             ([\n\r].*?[\n\r])?          # optional block of text
                             \}\}                        # closing tag
                             )
                            )/mx unless const_defined?(:MACROS_RE)
               MACRO_SUB_RE = /(
                               \{\{
                               macro\((\d+)\)
                               \}\}
                               )/x unless const_defined?(:MACRO_SUB_RE)
               # Extracts macros from text
               def catch_macros(text)
                 macros = {}
                 text.gsub!(MACROS_RE) do
                   all, macro = $1, $4.downcase
                   if macro_exists?(macro) || all =~ MACRO_SUB_RE
                     index = macros.size
                     macros[index] = all
                     "{{macro(#{index})}}"
                   else
                     all
                   end
                 end
                 macros
               end
               # Executes and replaces macros in text
               def inject_macros(text, obj, macros, execute=true)
                 text.gsub!(MACRO_SUB_RE) do
                   all, index = $1, $2.to_i
                   orig = macros.delete(index)
                   if execute && orig && orig =~ MACROS_RE
                     esc, all, macro, args, block = $2, $3, $4.downcase, $6.to_s, $7.try(:strip)
                     if esc.nil?
                       h(exec_macro(macro, obj, args, block) || all)
                     else
                       h(all)
                     end
                   elsif orig
                     h(orig)
                   else
                     h(all)
                   end
                 end
               end
               TOC_RE = /<p>\{\{([<>]?)toc\}\}<\/p>/i unless const_defined?(:TOC_RE)
               # Renders the TOC with given headings
               def replace_toc(text, headings)
                 text.gsub!(TOC_RE) do
                   # Keep only the 4 first levels
                   headings = headings.select{|level, anchor, item| level <= 4}
                   if headings.empty?
                     ''
                   else
                     div_class = 'toc'
                     div_class << ' right' if $1 == '>'
                     div_class << ' left' if $1 == '<'
                     out = "<ul class=\"#{div_class}\"><li>"
                     root = headings.map(&:first).min
                     current = root
                     started = false
                     headings.each do |level, anchor, item|
                       if level > current
                         out << '<ul><li>' * (level - current)
                       elsif level < current
                         out << "</li></ul>\n" * (current - level) + "</li><li>"
                       elsif started
                         out << '</li><li>'
                       end
                       out << "<a href=\"##{anchor}\">#{item}</a>"
                       current = level
                       started = true
                     end
                     out << '</li></ul>' * (current - root)
                     out << '</li></ul>'
                   end
                 end
               end
               # Same as Rails' simple_format helper without using paragraphs
               def simple_format_without_paragraph(text)
                 text.to_s.
                   gsub(/\r\n?/, "\n").                    # \r\n and \r -> \n
                   gsub(/\n\n+/, "<br /><br />").          # 2+ newline  -> 2 br
                   gsub(/([^\n]\n)(?=[^\n])/, '\1<br />'). # 1 newline   -> br
                   html_safe
               end
               def lang_options_for_select(blank=true)
                 (blank ? [["(auto)", ""]] : []) + languages_options
               end
               def label_tag_for(name, option_tags = nil, options = {})
                 label_text = l(("field_"+field.to_s.gsub(/\_id$/, "")).to_sym) + (options.delete(:required) ? @template.content_tag("span", " *", :class => "required"): "")
                 content_tag("label", label_text)
               end
               def labelled_form_for(*args, &proc)
                 args << {} unless args.last.is_a?(Hash)
                 options = args.last
                 if args.first.is_a?(Symbol)
                   options.merge!(:as => args.shift)
                 end
                 options.merge!({:builder => Redmine::Views::LabelledFormBuilder})
                 form_for(*args, &proc)
               end
               def labelled_fields_for(*args, &proc)
                 args << {} unless args.last.is_a?(Hash)
                 options = args.last
                 options.merge!({:builder => Redmine::Views::LabelledFormBuilder})
                 fields_for(*args, &proc)
               end
               def labelled_remote_form_for(*args, &proc)
                 ActiveSupport::Deprecation.warn "ApplicationHelper#labelled_remote_form_for is deprecated and will be removed in Redmine 2.2."
                 args << {} unless args.last.is_a?(Hash)
                 options = args.last
                 options.merge!({:builder => Redmine::Views::LabelledFormBuilder, :remote => true})
                 form_for(*args, &proc)
               end
               def error_messages_for(*objects)
                 html = ""
                 objects = objects.map {|o| o.is_a?(String) ? instance_variable_get("@#{o}") : o}.compact
                 errors = objects.map {|o| o.errors.full_messages}.flatten
                 if errors.any?
                   html << "<div id='errorExplanation'><ul>\n"
                   errors.each do |error|
                     html << "<li>#{h error}</li>\n"
                   end
                   html << "</ul></div>\n"
                 end
                 html.html_safe
               end
               def delete_link(url, options={})
                 options = {
                   :method => :delete,
                   :data => {:confirm => l(:text_are_you_sure)},
                   :class => 'icon icon-del'
                 }.merge(options)
                 link_to l(:button_delete), url, options
               end
               def preview_link(url, form, target='preview', options={})
                 content_tag 'a', l(:label_preview), {
                     :href => "#",
                     :onclick => %|submitPreview("#{escape_javascript url_for(url)}", "#{escape_javascript form}", "#{escape_javascript target}"); return false;|,
                     :accesskey => accesskey(:preview)
                   }.merge(options)
               end
               def link_to_function(name, function, html_options={})
                 content_tag(:a, name, {:href => '#', :onclick => "#{function}; return false;"}.merge(html_options))
               end
               # Helper to render JSON in views
               def raw_json(arg)
                 arg.to_json.to_s.gsub('/', '\/').html_safe
               end
               def back_url
                 url = params[:back_url]
                 if url.nil? && referer = request.env['HTTP_REFERER']
                   url = CGI.unescape(referer.to_s)
                 end
                 url
               end
               def back_url_hidden_field_tag
                 url = back_url
                 hidden_field_tag('back_url', url, :id => nil) unless url.blank?
               end
               def check_all_links(form_name)
                 link_to_function(l(:button_check_all), "checkAll('#{form_name}', true)") +
                 " | ".html_safe +
                 link_to_function(l(:button_uncheck_all), "checkAll('#{form_name}', false)")
               end
               def progress_bar(pcts, options={})
                 pcts = [pcts, pcts] unless pcts.is_a?(Array)
                 pcts = pcts.collect(&:round)
                 pcts[1] = pcts[1] - pcts[0]
                 pcts << (100 - pcts[1] - pcts[0])
                 width = options[:width] || '100px;'
                 legend = options[:legend] || ''
                 content_tag('table',
                   content_tag('tr',
                     (pcts[0] > 0 ? content_tag('td', '', :style => "width: #{pcts[0]}%;", :class => 'closed') : ''.html_safe) +
                     (pcts[1] > 0 ? content_tag('td', '', :style => "width: #{pcts[1]}%;", :class => 'done') : ''.html_safe) +
                     (pcts[2] > 0 ? content_tag('td', '', :style => "width: #{pcts[2]}%;", :class => 'todo') : ''.html_safe)
                   ), :class => 'progress', :style => "width: #{width};").html_safe +
                   content_tag('p', legend, :class => 'pourcent').html_safe
               end
               def checked_image(checked=true)
                 if checked
                   image_tag 'toggle_check.png'
                 end
               end
               def context_menu(url)
                 unless @context_menu_included
                   content_for :header_tags do
                     javascript_include_tag('context_menu') +
                       stylesheet_link_tag('context_menu')
                   end
                   if l(:direction) == 'rtl'
                     content_for :header_tags do
                       stylesheet_link_tag('context_menu_rtl')
                     end
                   end
                   @context_menu_included = true
                 end
                 javascript_tag "contextMenuInit('#{ url_for(url) }')"
               end
               def calendar_for(field_id)
                 include_calendar_headers_tags
                 javascript_tag("$(function() { $('##{field_id}').datepicker(datepickerOptions); });")
               end
               def include_calendar_headers_tags
                 unless @calendar_headers_tags_included
                   @calendar_headers_tags_included = true
                   content_for :header_tags do
                     start_of_week = Setting.start_of_week
                     start_of_week = l(:general_first_day_of_week, :default => '1') if start_of_week.blank?
                     # Redmine uses 1..7 (monday..sunday) in settings and locales
                     # JQuery uses 0..6 (sunday..saturday), 7 needs to be changed to 0
                     start_of_week = start_of_week.to_i % 7
                     tags = javascript_tag(
                                "var datepickerOptions={dateFormat: 'yy-mm-dd', firstDay: #{start_of_week}, " +
                                  "showOn: 'button', buttonImageOnly: true, buttonImage: '" +
                                  path_to_image('/images/calendar.png') +
                                  "', showButtonPanel: true};")
                     jquery_locale = l('jquery.locale', :default => current_language.to_s)
                     unless jquery_locale == 'en'
                       tags << javascript_include_tag("i18n/jquery.ui.datepicker-#{jquery_locale}.js")
                     end
                     tags
                   end
                 end
               end
               # Overrides Rails' stylesheet_link_tag with themes and plugins support.
               # Examples:
               #   stylesheet_link_tag('styles') # => picks styles.css from the current theme or defaults
               #   stylesheet_link_tag('styles', :plugin => 'foo) # => picks styles.css from plugin's assets
               #
               def stylesheet_link_tag(*sources)
                 options = sources.last.is_a?(Hash) ? sources.pop : {}
                 plugin = options.delete(:plugin)
                 sources = sources.map do |source|
                   if plugin
                     "/plugin_assets/#{plugin}/stylesheets/#{source}"
                   elsif current_theme && current_theme.stylesheets.include?(source)
                     current_theme.stylesheet_path(source)
                   else
                     source
                   end
                 end
                 super sources, options
               end
               # Overrides Rails' image_tag with themes and plugins support.
               # Examples:
               #   image_tag('image.png') # => picks image.png from the current theme or defaults
               #   image_tag('image.png', :plugin => 'foo) # => picks image.png from plugin's assets
               #
               def image_tag(source, options={})
                 if plugin = options.delete(:plugin)
                   source = "/plugin_assets/#{plugin}/images/#{source}"
                 elsif current_theme && current_theme.images.include?(source)
                   source = current_theme.image_path(source)
                 end
                 super source, options
               end
               # Overrides Rails' javascript_include_tag with plugins support
               # Examples:
               #   javascript_include_tag('scripts') # => picks scripts.js from defaults
               #   javascript_include_tag('scripts', :plugin => 'foo) # => picks scripts.js from plugin's assets
               #
               def javascript_include_tag(*sources)
                 options = sources.last.is_a?(Hash) ? sources.pop : {}
                 if plugin = options.delete(:plugin)
                   sources = sources.map do |source|
                     if plugin
                       "/plugin_assets/#{plugin}/javascripts/#{source}"
                     else
                       source
                     end
                   end
                 end
                 super sources, options
               end
               def content_for(name, content = nil, &block)
                 @has_content ||= {}
                 @has_content[name] = true
                 super(name, content, &block)
               end
               def has_content?(name)
                 (@has_content && @has_content[name]) || false
               end
               def sidebar_content?
                 has_content?(:sidebar) || view_layouts_base_sidebar_hook_response.present?
               end
               def view_layouts_base_sidebar_hook_response
                 @view_layouts_base_sidebar_hook_response ||= call_hook(:view_layouts_base_sidebar)
               end
               def email_delivery_enabled?
                 !!ActionMailer::Base.perform_deliveries
               end
               # Returns the avatar image tag for the given +user+ if avatars are enabled
               # +user+ can be a User or a string that will be scanned for an email address (eg. 'joe <joe@foo.bar>')
               def avatar(user, options = { })
                 if Setting.gravatar_enabled?
                   options.merge!({:ssl => (request && request.ssl?), :default => Setting.gravatar_default})
                   email = nil
                   if user.respond_to?(:mail)
                     email = user.mail
                   elsif user.to_s =~ %r{<(.+?)>}
                     email = $1
                   end
                   return gravatar(email.to_s.downcase, options) unless email.blank? rescue nil
                 else
                   ''
                 end
               end
               def sanitize_anchor_name(anchor)
                 if ''.respond_to?(:encoding) || RUBY_PLATFORM == 'java'
                   anchor.gsub(%r{[^\p{Word}\s\-]}, '').gsub(%r{\s+(\-+\s*)?}, '-')
                 else
                   # TODO: remove when ruby1.8 is no longer supported
                   anchor.gsub(%r{[^\w\s\-]}, '').gsub(%r{\s+(\-+\s*)?}, '-')
                 end
               end
               # Returns the javascript tags that are included in the html layout head
               def javascript_heads
                 tags = javascript_include_tag('jquery-1.7.2-ui-1.8.21-ujs-2.0.3', 'application')
                 unless User.current.pref.warn_on_leaving_unsaved == '0'
                   tags << "\n".html_safe + javascript_tag("$(window).load(function(){ warnLeavingUnsaved('#{escape_javascript l(:text_warn_on_leaving_unsaved)}'); });")
                 end
                 tags
               end
               def favicon
                 "<link rel='shortcut icon' href='#{image_path('/favicon.ico')}' />".html_safe
               end
               def robot_exclusion_tag
                 '<meta name="robots" content="noindex,follow,noarchive" />'.html_safe
               end
               # Returns true if arg is expected in the API response
               def include_in_api_response?(arg)
                 unless @included_in_api_response
                   param = params[:include]
                   @included_in_api_response = param.is_a?(Array) ? param.collect(&:to_s) : param.to_s.split(',')
                   @included_in_api_response.collect!(&:strip)
                 end
                 @included_in_api_response.include?(arg.to_s)
               end
               # Returns options or nil if nometa param or X-Redmine-Nometa header
               # was set in the request
               def api_meta(options)
                 if params[:nometa].present? || request.headers['X-Redmine-Nometa']
                   # compatibility mode for activeresource clients that raise
                   # an error when unserializing an array with attributes
                   nil
                 else
                   options
                 end
               end
               private
               def wiki_helper
                 helper = Redmine::WikiFormatting.helper_for(Setting.text_formatting)
                 extend helper
                 return self
               end
               def link_to_content_update(text, url_params = {}, html_options = {})
                 link_to(text, url_params, html_options)
               end
             end

test/fixtures/wiki_content_versions.yml +14 0

             ---
             wiki_content_versions_001:
               updated_on: 2007-03-07 00:08:07 +01:00
               page_id: 1
               id: 1
               version: 1
               author_id: 2
               comments: Page creation
               wiki_content_id: 1
               compression: ""
               data: |-
                 h1. CookBook documentation
                 Some [[documentation]] here...
             wiki_content_versions_002:
               updated_on: 2007-03-07 00:08:34 +01:00
               page_id: 1
               id: 2
               version: 2
               author_id: 1
               comments: Small update
               wiki_content_id: 1
               compression: ""
               data: |-
                 h1. CookBook documentation
                 Some updated [[documentation]] here...
             wiki_content_versions_003:
               updated_on: 2007-03-07 00:10:51 +01:00
               page_id: 1
               id: 3
               version: 3
               author_id: 1
               comments: ""
               wiki_content_id: 1
               compression: ""
               data: |-
                 h1. CookBook documentation
                 Some updated [[documentation]] here...
             wiki_content_versions_004:
               data: |-
                 h1. Another page
                 This is a link to a ticket: #2
               updated_on: 2007-03-08 00:18:07 +01:00
               page_id: 2
               wiki_content_id: 2
               id: 4
               version: 1
               author_id: 1
               comments:
             wiki_content_versions_005:
               data: |-
                 h1. Title
                 Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Maecenas sed libero.
                 h2. Heading 1
                 @WHATEVER@
                 Maecenas sed elit sit amet mi accumsan vestibulum non nec velit. Proin porta tincidunt lorem, consequat rhoncus dolor fermentum in.
                 Cras ipsum felis, ultrices at porttitor vel, faucibus eu nunc.
                 h2. Heading 2
                 Morbi facilisis accumsan orci non pharetra.
               updated_on: 2007-03-08 00:16:07 +01:00
               page_id: 11
               wiki_content_id: 11
               id: 5
               version: 2
               author_id: 1
               comments:
             wiki_content_versions_006:
               data: |-
                 h1. Title
                 Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Maecenas sed libero.
                 h2. Heading 1
                 @WHATEVER@
                 Maecenas sed elit sit amet mi accumsan vestibulum non nec velit. Proin porta tincidunt lorem, consequat rhoncus dolor fermentum in.
                 h2. Heading 2
                 Morbi facilisis accumsan orci non pharetra.
               updated_on: 2007-03-08 00:18:07 +01:00
               page_id: 11
               wiki_content_id: 11
               id: 6
               version: 3
               author_id: 1
               comments:
+            wiki_content_versions_007:
+              data: |-
+                h1. Page with an inline image
+                This is an inline image:
+                !logo.gif!
+              updated_on: 2007-03-08 00:18:07 +01:00
+              page_id: 4
+              wiki_content_id: 4
+              id: 7
+              version: 1
+              author_id: 1
+              comments:

test/functional/wiki_controller_test.rb +13 0

             # Redmine - project management software
             # Copyright (C) 2006-2012  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require File.expand_path('../../test_helper', __FILE__)
             require 'wiki_controller'
             # Re-raise errors caught by the controller.
             class WikiController; def rescue_action(e) raise e end; end
             class WikiControllerTest < ActionController::TestCase
               fixtures :projects, :users, :roles, :members, :member_roles,
                        :enabled_modules, :wikis, :wiki_pages, :wiki_contents,
                        :wiki_content_versions, :attachments
               def setup
                 @controller = WikiController.new
                 @request    = ActionController::TestRequest.new
                 @response   = ActionController::TestResponse.new
                 User.current = nil
               end
               def test_show_start_page
                 get :show, :project_id => 'ecookbook'
                 assert_response :success
                 assert_template 'show'
                 assert_tag :tag => 'h1', :content => /CookBook documentation/
                 # child_pages macro
                 assert_tag :ul, :attributes => { :class => 'pages-hierarchy' },
                            :child => { :tag => 'li',
                                        :child => { :tag => 'a', :attributes => { :href => '/projects/ecookbook/wiki/Page_with_an_inline_image' },
                                                                 :content => 'Page with an inline image' } }
               end
               def test_export_link
                 Role.anonymous.add_permission! :export_wiki_pages
                 get :show, :project_id => 'ecookbook'
                 assert_response :success
                 assert_tag 'a', :attributes => {:href => '/projects/ecookbook/wiki/CookBook_documentation.txt'}
               end
               def test_show_page_with_name
                 get :show, :project_id => 1, :id => 'Another_page'
                 assert_response :success
                 assert_template 'show'
                 assert_tag :tag => 'h1', :content => /Another page/
                 # Included page with an inline image
                 assert_tag :tag => 'p', :content => /This is an inline image/
                 assert_tag :tag => 'img', :attributes => { :src => '/attachments/download/3',
                                                            :alt => 'This is a logo' }
               end
               def test_show_old_version
                 get :show, :project_id => 'ecookbook', :id => 'CookBook_documentation', :version => '2'
                 assert_response :success
                 assert_template 'show'
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/1', :text => /Previous/
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/2/diff', :text => /diff/
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/3', :text => /Next/
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation', :text => /Current version/
               end
+              def test_show_old_version_with_attachments
+                page = WikiPage.find(4)
+                assert page.attachments.any?
+                content = page.content
+                content.text = "update"
+                content.save!
+                get :show, :project_id => 'ecookbook', :id => page.title, :version => '1'
+                assert_kind_of WikiContent::Version, assigns(:content)
+                assert_response :success
+                assert_template 'show'
+              end
               def test_show_old_version_without_permission_should_be_denied
                 Role.anonymous.remove_permission! :view_wiki_edits
                 get :show, :project_id => 'ecookbook', :id => 'CookBook_documentation', :version => '2'
                 assert_redirected_to '/login?back_url=http%3A%2F%2Ftest.host%2Fprojects%2Fecookbook%2Fwiki%2FCookBook_documentation%2F2'
               end
               def test_show_first_version
                 get :show, :project_id => 'ecookbook', :id => 'CookBook_documentation', :version => '1'
                 assert_response :success
                 assert_template 'show'
                 assert_select 'a', :text => /Previous/, :count => 0
                 assert_select 'a', :text => /diff/, :count => 0
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/2', :text => /Next/
                 assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation', :text => /Current version/
               end
               def test_show_redirected_page
                 WikiRedirect.create!(:wiki_id => 1, :title => 'Old_title', :redirects_to => 'Another_page')
                 get :show, :project_id => 'ecookbook', :id => 'Old_title'
                 assert_redirected_to '/projects/ecookbook/wiki/Another_page'
               end
               def test_show_with_sidebar
                 page = Project.find(1).wiki.pages.new(:title => 'Sidebar')
                 page.content = WikiContent.new(:text => 'Side bar content for test_show_with_sidebar')
                 page.save!
                 get :show, :project_id => 1, :id => 'Another_page'
                 assert_response :success
                 assert_tag :tag => 'div', :attributes => {:id => 'sidebar'},
                                           :content => /Side bar content for test_show_with_sidebar/
               end
               def test_show_should_display_section_edit_links
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1, :id => 'Page with sections'
                 assert_no_tag 'a', :attributes => {
                   :href => '/projects/ecookbook/wiki/Page_with_sections/edit?section=1'
                 }
                 assert_tag 'a', :attributes => {
                   :href => '/projects/ecookbook/wiki/Page_with_sections/edit?section=2'
                 }
                 assert_tag 'a', :attributes => {
                   :href => '/projects/ecookbook/wiki/Page_with_sections/edit?section=3'
                 }
               end
               def test_show_current_version_should_display_section_edit_links
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1, :id => 'Page with sections', :version => 3
                 assert_tag 'a', :attributes => {
                   :href => '/projects/ecookbook/wiki/Page_with_sections/edit?section=2'
                 }
               end
               def test_show_old_version_should_not_display_section_edit_links
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1, :id => 'Page with sections', :version => 2
                 assert_no_tag 'a', :attributes => {
                   :href => '/projects/ecookbook/wiki/Page_with_sections/edit?section=2'
                 }
               end
               def test_show_unexistent_page_without_edit_right
                 get :show, :project_id => 1, :id => 'Unexistent page'
                 assert_response 404
               end
               def test_show_unexistent_page_with_edit_right
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1, :id => 'Unexistent page'
                 assert_response :success
                 assert_template 'edit'
               end
               def test_show_unexistent_page_with_parent_should_preselect_parent
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1, :id => 'Unexistent page', :parent => 'Another_page'
                 assert_response :success
                 assert_template 'edit'
                 assert_tag 'select', :attributes => {:name => 'wiki_page[parent_id]'},
                   :child => {:tag => 'option', :attributes => {:value => '2', :selected => 'selected'}}
               end
               def test_show_should_not_show_history_without_permission
                 Role.anonymous.remove_permission! :view_wiki_edits
                 get :show, :project_id => 1, :id => 'Page with sections', :version => 2
                 assert_response 302
               end
               def test_create_page
                 @request.session[:user_id] = 2
                 assert_difference 'WikiPage.count' do
                   assert_difference 'WikiContent.count' do
                     put :update, :project_id => 1,
                                 :id => 'New page',
                                 :content => {:comments => 'Created the page',
                                              :text => "h1. New page\n\nThis is a new page",
                                              :version => 0}
                   end
                 end
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'New_page'
                 page = Project.find(1).wiki.find_page('New page')
                 assert !page.new_record?
                 assert_not_nil page.content
                 assert_nil page.parent
                 assert_equal 'Created the page', page.content.comments
               end
               def test_create_page_with_attachments
                 @request.session[:user_id] = 2
                 assert_difference 'WikiPage.count' do
                   assert_difference 'Attachment.count' do
                     put :update, :project_id => 1,
                                 :id => 'New page',
                                 :content => {:comments => 'Created the page',
                                              :text => "h1. New page\n\nThis is a new page",
                                              :version => 0},
                                 :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain')}}
                   end
                 end
                 page = Project.find(1).wiki.find_page('New page')
                 assert_equal 1, page.attachments.count
                 assert_equal 'testfile.txt', page.attachments.first.filename
               end
               def test_create_page_with_parent
                 @request.session[:user_id] = 2
                 assert_difference 'WikiPage.count' do
                   put :update, :project_id => 1, :id => 'New page',
                     :content => {:text => "h1. New page\n\nThis is a new page", :version => 0},
                     :wiki_page => {:parent_id => 2}
                 end
                 page = Project.find(1).wiki.find_page('New page')
                 assert_equal WikiPage.find(2), page.parent
               end
               def test_edit_page
                 @request.session[:user_id] = 2
                 get :edit, :project_id => 'ecookbook', :id => 'Another_page'
                 assert_response :success
                 assert_template 'edit'
                 assert_tag 'textarea',
                   :attributes => { :name => 'content[text]' },
                   :content => "\n"+WikiPage.find_by_title('Another_page').content.text
               end
               def test_edit_section
                 @request.session[:user_id] = 2
                 get :edit, :project_id => 'ecookbook', :id => 'Page_with_sections', :section => 2
                 assert_response :success
                 assert_template 'edit'
                 page = WikiPage.find_by_title('Page_with_sections')
                 section, hash = Redmine::WikiFormatting::Textile::Formatter.new(page.content.text).get_section(2)
                 assert_tag 'textarea',
                   :attributes => { :name => 'content[text]' },
                   :content => "\n"+section
                 assert_tag 'input',
                   :attributes => { :name => 'section', :type => 'hidden', :value => '2' }
                 assert_tag 'input',
                   :attributes => { :name => 'section_hash', :type => 'hidden', :value => hash }
               end
               def test_edit_invalid_section_should_respond_with_404
                 @request.session[:user_id] = 2
                 get :edit, :project_id => 'ecookbook', :id => 'Page_with_sections', :section => 10
                 assert_response 404
               end
               def test_update_page
                 @request.session[:user_id] = 2
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_difference 'WikiContent::Version.count' do
                       put :update, :project_id => 1,
                         :id => 'Another_page',
                         :content => {
                           :comments => "my comments",
                           :text => "edited",
                           :version => 1
                         }
                     end
                   end
                 end
                 assert_redirected_to '/projects/ecookbook/wiki/Another_page'
                 page = Wiki.find(1).pages.find_by_title('Another_page')
                 assert_equal "edited", page.content.text
                 assert_equal 2, page.content.version
                 assert_equal "my comments", page.content.comments
               end
               def test_update_page_with_parent
                 @request.session[:user_id] = 2
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_difference 'WikiContent::Version.count' do
                       put :update, :project_id => 1,
                         :id => 'Another_page',
                         :content => {
                           :comments => "my comments",
                           :text => "edited",
                           :version => 1
                         },
                         :wiki_page => {:parent_id => '1'}
                     end
                   end
                 end
                 assert_redirected_to '/projects/ecookbook/wiki/Another_page'
                 page = Wiki.find(1).pages.find_by_title('Another_page')
                 assert_equal "edited", page.content.text
                 assert_equal 2, page.content.version
                 assert_equal "my comments", page.content.comments
                 assert_equal WikiPage.find(1), page.parent
               end
               def test_update_page_with_failure
                 @request.session[:user_id] = 2
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_no_difference 'WikiContent::Version.count' do
                       put :update, :project_id => 1,
                         :id => 'Another_page',
                         :content => {
                           :comments => 'a' * 300,  # failure here, comment is too long
                           :text => 'edited',
                           :version => 1
                         }
                       end
                     end
                   end
                 assert_response :success
                 assert_template 'edit'
                 assert_error_tag :descendant => {:content => /Comment is too long/}
                 assert_tag :tag => 'textarea', :attributes => {:id => 'content_text'}, :content => "\nedited"
                 assert_tag :tag => 'input', :attributes => {:id => 'content_version', :value => '1'}
               end
               def test_update_page_with_parent_change_only_should_not_create_content_version
                 @request.session[:user_id] = 2
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_no_difference 'WikiContent::Version.count' do
                       put :update, :project_id => 1,
                         :id => 'Another_page',
                         :content => {
                           :comments => '',
                           :text => Wiki.find(1).find_page('Another_page').content.text,
                           :version => 1
                         },
                         :wiki_page => {:parent_id => '1'}
                     end
                   end
                 end
                 page = Wiki.find(1).pages.find_by_title('Another_page')
                 assert_equal 1, page.content.version
                 assert_equal WikiPage.find(1), page.parent
               end
               def test_update_page_with_attachments_only_should_not_create_content_version
                 @request.session[:user_id] = 2
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_no_difference 'WikiContent::Version.count' do
                       assert_difference 'Attachment.count' do
                         put :update, :project_id => 1,
                           :id => 'Another_page',
                           :content => {
                             :comments => '',
                             :text => Wiki.find(1).find_page('Another_page').content.text,
                             :version => 1
                           },
                           :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain'), 'description' => 'test file'}}
                       end
                     end
                   end
                 end
                 page = Wiki.find(1).pages.find_by_title('Another_page')
                 assert_equal 1, page.content.version
               end
               def test_update_stale_page_should_not_raise_an_error
                 @request.session[:user_id] = 2
                 c = Wiki.find(1).find_page('Another_page').content
                 c.text = 'Previous text'
                 c.save!
                 assert_equal 2, c.version
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_no_difference 'WikiContent::Version.count' do
                       put :update, :project_id => 1,
                         :id => 'Another_page',
                         :content => {
                           :comments => 'My comments',
                           :text => 'Text should not be lost',
                           :version => 1
                         }
                     end
                   end
                 end
                 assert_response :success
                 assert_template 'edit'
                 assert_tag :div,
                   :attributes => { :class => /error/ },
                   :content => /Data has been updated by another user/
                 assert_tag 'textarea',
                   :attributes => { :name => 'content[text]' },
                   :content => /Text should not be lost/
                 assert_tag 'input',
                   :attributes => { :name => 'content[comments]', :value => 'My comments' }
                 c.reload
                 assert_equal 'Previous text', c.text
                 assert_equal 2, c.version
               end
               def test_update_section
                 @request.session[:user_id] = 2
                 page = WikiPage.find_by_title('Page_with_sections')
                 section, hash = Redmine::WikiFormatting::Textile::Formatter.new(page.content.text).get_section(2)
                 text = page.content.text
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_difference 'WikiContent::Version.count' do
                       put :update, :project_id => 1, :id => 'Page_with_sections',
                         :content => {
                           :text => "New section content",
                           :version => 3
                         },
                         :section => 2,
                         :section_hash => hash
                     end
                   end
                 end
                 assert_redirected_to '/projects/ecookbook/wiki/Page_with_sections'
                 assert_equal Redmine::WikiFormatting::Textile::Formatter.new(text).update_section(2, "New section content"), page.reload.content.text
               end
               def test_update_section_should_allow_stale_page_update
                 @request.session[:user_id] = 2
                 page = WikiPage.find_by_title('Page_with_sections')
                 section, hash = Redmine::WikiFormatting::Textile::Formatter.new(page.content.text).get_section(2)
                 text = page.content.text
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_difference 'WikiContent::Version.count' do
                       put :update, :project_id => 1, :id => 'Page_with_sections',
                         :content => {
                           :text => "New section content",
                           :version => 2 # Current version is 3
                         },
                         :section => 2,
                         :section_hash => hash
                     end
                   end
                 end
                 assert_redirected_to '/projects/ecookbook/wiki/Page_with_sections'
                 page.reload
                 assert_equal Redmine::WikiFormatting::Textile::Formatter.new(text).update_section(2, "New section content"), page.content.text
                 assert_equal 4, page.content.version
               end
               def test_update_section_should_not_allow_stale_section_update
                 @request.session[:user_id] = 2
                 assert_no_difference 'WikiPage.count' do
                   assert_no_difference 'WikiContent.count' do
                     assert_no_difference 'WikiContent::Version.count' do
                       put :update, :project_id => 1, :id => 'Page_with_sections',
                         :content => {
                           :comments => 'My comments',
                           :text => "Text should not be lost",
                           :version => 3
                         },
                         :section => 2,
                         :section_hash => Digest::MD5.hexdigest("wrong hash")
                     end
                   end
                 end
                 assert_response :success
                 assert_template 'edit'
                 assert_tag :div,
                   :attributes => { :class => /error/ },
                   :content => /Data has been updated by another user/
                 assert_tag 'textarea',
                   :attributes => { :name => 'content[text]' },
                   :content => /Text should not be lost/
                 assert_tag 'input',
                   :attributes => { :name => 'content[comments]', :value => 'My comments' }
               end
               def test_preview
                 @request.session[:user_id] = 2
                 xhr :post, :preview, :project_id => 1, :id => 'CookBook_documentation',
                                                :content => { :comments => '',
                                                              :text => 'this is a *previewed text*',
                                                              :version => 3 }
                 assert_response :success
                 assert_template 'common/_preview'
                 assert_tag :tag => 'strong', :content => /previewed text/
               end
               def test_preview_new_page
                 @request.session[:user_id] = 2
                 xhr :post, :preview, :project_id => 1, :id => 'New page',
                                                :content => { :text => 'h1. New page',
                                                              :comments => '',
                                                              :version => 0 }
                 assert_response :success
                 assert_template 'common/_preview'
                 assert_tag :tag => 'h1', :content => /New page/
               end
               def test_history
                 @request.session[:user_id] = 2
                 get :history, :project_id => 'ecookbook', :id => 'CookBook_documentation'
                 assert_response :success
                 assert_template 'history'
                 assert_not_nil assigns(:versions)
                 assert_equal 3, assigns(:versions).size
                 assert_select "input[type=submit][name=commit]"
                 assert_select 'td' do
                   assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/2', :text => '2'
                   assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/2/annotate', :text => 'Annotate'
                   assert_select 'a[href=?]', '/projects/ecookbook/wiki/CookBook_documentation/2', :text => 'Delete'
                 end
               end
               def test_history_with_one_version
                 @request.session[:user_id] = 2
                 get :history, :project_id => 'ecookbook', :id => 'Another_page'
                 assert_response :success
                 assert_template 'history'
                 assert_not_nil assigns(:versions)
                 assert_equal 1, assigns(:versions).size
                 assert_select "input[type=submit][name=commit]", false
                 assert_select 'td' do
                   assert_select 'a[href=?]', '/projects/ecookbook/wiki/Another_page/1', :text => '1'
                   assert_select 'a[href=?]', '/projects/ecookbook/wiki/Another_page/1/annotate', :text => 'Annotate'
                   assert_select 'a[href=?]', '/projects/ecookbook/wiki/Another_page/1', :text => 'Delete', :count => 0
                 end
               end
               def test_diff
                 content = WikiPage.find(1).content
                 assert_difference 'WikiContent::Version.count', 2 do
                   content.text = "Line removed\nThis is a sample text for testing diffs"
                   content.save!
                   content.text = "This is a sample text for testing diffs\nLine added"
                   content.save!
                 end
                 get :diff, :project_id => 1, :id => 'CookBook_documentation', :version => content.version, :version_from => (content.version - 1)
                 assert_response :success
                 assert_template 'diff'
                 assert_select 'span.diff_out', :text => 'Line removed'
                 assert_select 'span.diff_in', :text => 'Line added'
               end
               def test_diff_with_invalid_version_should_respond_with_404
                 get :diff, :project_id => 1, :id => 'CookBook_documentation', :version => '99'
                 assert_response 404
               end
               def test_diff_with_invalid_version_from_should_respond_with_404
                 get :diff, :project_id => 1, :id => 'CookBook_documentation', :version => '99', :version_from => '98'
                 assert_response 404
               end
               def test_annotate
                 get :annotate, :project_id => 1, :id =>  'CookBook_documentation', :version => 2
                 assert_response :success
                 assert_template 'annotate'
                 # Line 1
                 assert_tag :tag => 'tr', :child => {
                   :tag => 'th', :attributes => {:class => 'line-num'}, :content => '1', :sibling => {
                     :tag => 'td', :attributes => {:class => 'author'}, :content => /John Smith/, :sibling => {
                       :tag => 'td', :content => /h1\. CookBook documentation/
                     }
                   }
                 }
                 # Line 5
                 assert_tag :tag => 'tr', :child => {
                   :tag => 'th', :attributes => {:class => 'line-num'}, :content => '5', :sibling => {
                     :tag => 'td', :attributes => {:class => 'author'}, :content => /redMine Admin/, :sibling => {
                       :tag => 'td', :content => /Some updated \[\[documentation\]\] here/
                     }
                   }
                 }
               end
               def test_annotate_with_invalid_version_should_respond_with_404
                 get :annotate, :project_id => 1, :id => 'CookBook_documentation', :version => '99'
                 assert_response 404
               end
               def test_get_rename
                 @request.session[:user_id] = 2
                 get :rename, :project_id => 1, :id => 'Another_page'
                 assert_response :success
                 assert_template 'rename'
                 assert_tag 'option',
                   :attributes => {:value => ''},
                   :content => '',
                   :parent => {:tag => 'select', :attributes => {:name => 'wiki_page[parent_id]'}}
                 assert_no_tag 'option',
                   :attributes => {:selected => 'selected'},
                   :parent => {:tag => 'select', :attributes => {:name => 'wiki_page[parent_id]'}}
               end
               def test_get_rename_child_page
                 @request.session[:user_id] = 2
                 get :rename, :project_id => 1, :id => 'Child_1'
                 assert_response :success
                 assert_template 'rename'
                 assert_tag 'option',
                   :attributes => {:value => ''},
                   :content => '',
                   :parent => {:tag => 'select', :attributes => {:name => 'wiki_page[parent_id]'}}
                 assert_tag 'option',
                   :attributes => {:value => '2', :selected => 'selected'},
                   :content => /Another page/,
                   :parent => {
                     :tag => 'select',
                     :attributes => {:name => 'wiki_page[parent_id]'}
                   }
               end
               def test_rename_with_redirect
                 @request.session[:user_id] = 2
                 post :rename, :project_id => 1, :id => 'Another_page',
                                         :wiki_page => { :title => 'Another renamed page',
                                                         :redirect_existing_links => 1 }
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'Another_renamed_page'
                 wiki = Project.find(1).wiki
                 # Check redirects
                 assert_not_nil wiki.find_page('Another page')
                 assert_nil wiki.find_page('Another page', :with_redirect => false)
               end
               def test_rename_without_redirect
                 @request.session[:user_id] = 2
                 post :rename, :project_id => 1, :id => 'Another_page',
                                         :wiki_page => { :title => 'Another renamed page',
                                                         :redirect_existing_links => "0" }
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'Another_renamed_page'
                 wiki = Project.find(1).wiki
                 # Check that there's no redirects
                 assert_nil wiki.find_page('Another page')
               end
               def test_rename_with_parent_assignment
                 @request.session[:user_id] = 2
                 post :rename, :project_id => 1, :id => 'Another_page',
                   :wiki_page => { :title => 'Another page', :redirect_existing_links => "0", :parent_id => '4' }
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'Another_page'
                 assert_equal WikiPage.find(4), WikiPage.find_by_title('Another_page').parent
               end
               def test_rename_with_parent_unassignment
                 @request.session[:user_id] = 2
                 post :rename, :project_id => 1, :id => 'Child_1',
                   :wiki_page => { :title => 'Child 1', :redirect_existing_links => "0", :parent_id => '' }
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'Child_1'
                 assert_nil WikiPage.find_by_title('Child_1').parent
               end
               def test_destroy_a_page_without_children_should_not_ask_confirmation
                 @request.session[:user_id] = 2
                 delete :destroy, :project_id => 1, :id => 'Child_2'
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
               end
               def test_destroy_parent_should_ask_confirmation
                 @request.session[:user_id] = 2
                 assert_no_difference('WikiPage.count') do
                   delete :destroy, :project_id => 1, :id => 'Another_page'
                 end
                 assert_response :success
                 assert_template 'destroy'
                 assert_select 'form' do
                   assert_select 'input[name=todo][value=nullify]'
                   assert_select 'input[name=todo][value=destroy]'
                   assert_select 'input[name=todo][value=reassign]'
                 end
               end
               def test_destroy_parent_with_nullify_should_delete_parent_only
                 @request.session[:user_id] = 2
                 assert_difference('WikiPage.count', -1) do
                   delete :destroy, :project_id => 1, :id => 'Another_page', :todo => 'nullify'
                 end
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert_nil WikiPage.find_by_id(2)
               end
               def test_destroy_parent_with_cascade_should_delete_descendants
                 @request.session[:user_id] = 2
                 assert_difference('WikiPage.count', -4) do
                   delete :destroy, :project_id => 1, :id => 'Another_page', :todo => 'destroy'
                 end
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert_nil WikiPage.find_by_id(2)
                 assert_nil WikiPage.find_by_id(5)
               end
               def test_destroy_parent_with_reassign
                 @request.session[:user_id] = 2
                 assert_difference('WikiPage.count', -1) do
                   delete :destroy, :project_id => 1, :id => 'Another_page', :todo => 'reassign', :reassign_to_id => 1
                 end
                 assert_redirected_to :action => 'index', :project_id => 'ecookbook'
                 assert_nil WikiPage.find_by_id(2)
                 assert_equal WikiPage.find(1), WikiPage.find_by_id(5).parent
               end
               def test_destroy_version
                 @request.session[:user_id] = 2
                 assert_difference 'WikiContent::Version.count', -1 do
                   assert_no_difference 'WikiContent.count' do
                     assert_no_difference 'WikiPage.count' do
                       delete :destroy_version, :project_id => 'ecookbook', :id => 'CookBook_documentation', :version => 2
                       assert_redirected_to '/projects/ecookbook/wiki/CookBook_documentation/history'
                     end
                   end
                 end
               end
               def test_index
                 get :index, :project_id => 'ecookbook'
                 assert_response :success
                 assert_template 'index'
                 pages = assigns(:pages)
                 assert_not_nil pages
                 assert_equal Project.find(1).wiki.pages.size, pages.size
                 assert_equal pages.first.content.updated_on, pages.first.updated_on
                 assert_tag :ul, :attributes => { :class => 'pages-hierarchy' },
                                 :child => { :tag => 'li', :child => { :tag => 'a', :attributes => { :href => '/projects/ecookbook/wiki/CookBook_documentation' },
                                                           :content => 'CookBook documentation' },
                                             :child => { :tag => 'ul',
                                                         :child => { :tag => 'li',
                                                                     :child => { :tag => 'a', :attributes => { :href => '/projects/ecookbook/wiki/Page_with_an_inline_image' },
                                                                                              :content => 'Page with an inline image' } } } },
                                 :child => { :tag => 'li', :child => { :tag => 'a', :attributes => { :href => '/projects/ecookbook/wiki/Another_page' },
                                                                                    :content => 'Another page' } }
               end
               def test_index_should_include_atom_link
                 get :index, :project_id => 'ecookbook'
                 assert_tag 'a', :attributes => { :href => '/projects/ecookbook/activity.atom?show_wiki_edits=1'}
               end
               def test_export_to_html
                 @request.session[:user_id] = 2
                 get :export, :project_id => 'ecookbook'
                 assert_response :success
                 assert_not_nil assigns(:pages)
                 assert assigns(:pages).any?
                 assert_equal "text/html", @response.content_type
                 assert_select "a[name=?]", "CookBook_documentation"
                 assert_select "a[name=?]", "Another_page"
                 assert_select "a[name=?]", "Page_with_an_inline_image"
               end
               def test_export_to_pdf
                 @request.session[:user_id] = 2
                 get :export, :project_id => 'ecookbook', :format => 'pdf'
                 assert_response :success
                 assert_not_nil assigns(:pages)
                 assert assigns(:pages).any?
                 assert_equal 'application/pdf', @response.content_type
                 assert_equal 'attachment; filename="ecookbook.pdf"', @response.headers['Content-Disposition']
                 assert @response.body.starts_with?('%PDF')
               end
               def test_export_without_permission_should_be_denied
                 @request.session[:user_id] = 2
                 Role.find_by_name('Manager').remove_permission! :export_wiki_pages
                 get :export, :project_id => 'ecookbook'
                 assert_response 403
               end
               def test_date_index
                 get :date_index, :project_id => 'ecookbook'
                 assert_response :success
                 assert_template 'date_index'
                 assert_not_nil assigns(:pages)
                 assert_not_nil assigns(:pages_by_date)
                 assert_tag 'a', :attributes => { :href => '/projects/ecookbook/activity.atom?show_wiki_edits=1'}
               end
               def test_not_found
                 get :show, :project_id => 999
                 assert_response 404
               end
               def test_protect_page
                 page = WikiPage.find_by_wiki_id_and_title(1, 'Another_page')
                 assert !page.protected?
                 @request.session[:user_id] = 2
                 post :protect, :project_id => 1, :id => page.title, :protected => '1'
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'Another_page'
                 assert page.reload.protected?
               end
               def test_unprotect_page
                 page = WikiPage.find_by_wiki_id_and_title(1, 'CookBook_documentation')
                 assert page.protected?
                 @request.session[:user_id] = 2
                 post :protect, :project_id => 1, :id => page.title, :protected => '0'
                 assert_redirected_to :action => 'show', :project_id => 'ecookbook', :id => 'CookBook_documentation'
                 assert !page.reload.protected?
               end
               def test_show_page_with_edit_link
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1
                 assert_response :success
                 assert_template 'show'
                 assert_tag :tag => 'a', :attributes => { :href => '/projects/1/wiki/CookBook_documentation/edit' }
               end
               def test_show_page_without_edit_link
                 @request.session[:user_id] = 4
                 get :show, :project_id => 1
                 assert_response :success
                 assert_template 'show'
                 assert_no_tag :tag => 'a', :attributes => { :href => '/projects/1/wiki/CookBook_documentation/edit' }
               end
               def test_show_pdf
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1, :format => 'pdf'
                 assert_response :success
                 assert_not_nil assigns(:page)
                 assert_equal 'application/pdf', @response.content_type
                 assert_equal 'attachment; filename="CookBook_documentation.pdf"',
                               @response.headers['Content-Disposition']
               end
               def test_show_html
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1, :format => 'html'
                 assert_response :success
                 assert_not_nil assigns(:page)
                 assert_equal 'text/html', @response.content_type
                 assert_equal 'attachment; filename="CookBook_documentation.html"',
                               @response.headers['Content-Disposition']
                 assert_tag 'h1', :content => 'CookBook documentation'
               end
               def test_show_versioned_html
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1, :format => 'html', :version => 2
                 assert_response :success
                 assert_not_nil assigns(:content)
                 assert_equal 2, assigns(:content).version
                 assert_equal 'text/html', @response.content_type
                 assert_equal 'attachment; filename="CookBook_documentation.html"',
                               @response.headers['Content-Disposition']
                 assert_tag 'h1', :content => 'CookBook documentation'
               end
               def test_show_txt
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1, :format => 'txt'
                 assert_response :success
                 assert_not_nil assigns(:page)
                 assert_equal 'text/plain', @response.content_type
                 assert_equal 'attachment; filename="CookBook_documentation.txt"',
                               @response.headers['Content-Disposition']
                 assert_include 'h1. CookBook documentation', @response.body
               end
               def test_show_versioned_txt
                 @request.session[:user_id] = 2
                 get :show, :project_id => 1, :format => 'txt', :version => 2
                 assert_response :success
                 assert_not_nil assigns(:content)
                 assert_equal 2, assigns(:content).version
                 assert_equal 'text/plain', @response.content_type
                 assert_equal 'attachment; filename="CookBook_documentation.txt"',
                               @response.headers['Content-Disposition']
                 assert_include 'h1. CookBook documentation', @response.body
               end
               def test_edit_unprotected_page
                 # Non members can edit unprotected wiki pages
                 @request.session[:user_id] = 4
                 get :edit, :project_id => 1, :id => 'Another_page'
                 assert_response :success
                 assert_template 'edit'
               end
               def test_edit_protected_page_by_nonmember
                 # Non members can't edit protected wiki pages
                 @request.session[:user_id] = 4
                 get :edit, :project_id => 1, :id => 'CookBook_documentation'
                 assert_response 403
               end
               def test_edit_protected_page_by_member
                 @request.session[:user_id] = 2
                 get :edit, :project_id => 1, :id => 'CookBook_documentation'
                 assert_response :success
                 assert_template 'edit'
               end
               def test_history_of_non_existing_page_should_return_404
                 get :history, :project_id => 1, :id => 'Unknown_page'
                 assert_response 404
               end
               def test_add_attachment
                 @request.session[:user_id] = 2
                 assert_difference 'Attachment.count' do
                   post :add_attachment, :project_id => 1, :id => 'CookBook_documentation',
                     :attachments => {'1' => {'file' => uploaded_test_file('testfile.txt', 'text/plain'), 'description' => 'test file'}}
                 end
                 attachment = Attachment.first(:order => 'id DESC')
                 assert_equal Wiki.find(1).find_page('CookBook_documentation'), attachment.container
               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