jro_apps/redmine Commit - r10462:7729178d9d50

Adds links to locked users when current user is admin....

Jean-Philippe Lang -

r10462:7729178d9d50

parent child

Context file:

r10462:7729178d9d50

Collapse all files

app/helpers/application_helper.rb +2 -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?
+                  if user.active? || (User.current.admin? && user.logged?)
-                    link_to name, :controller => 'users', :action => 'show', :id => user
+                    link_to name, {:controller => 'users', :action => 'show', :id => 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, {:controller => "issues", :action => "show", :id => 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 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},
                                        :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
               # 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] || obj.attachments
                   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, :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 = attachments.detect {|a| a.filename == 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)", ""]] : []) +
                   valid_languages.collect{|lang| [ ll(lang.to_s, :general_lang_name), lang.to_s]}.sort{|x,y| x.last <=> y.last }
               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

app/models/user.rb +11 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 "digest/sha1"
             class User < Principal
               include Redmine::SafeAttributes
               # Account statuses
               STATUS_ANONYMOUS  = 0
               STATUS_ACTIVE     = 1
               STATUS_REGISTERED = 2
               STATUS_LOCKED     = 3
               # Different ways of displaying/sorting users
               USER_FORMATS = {
                 :firstname_lastname => {
                     :string => '#{firstname} #{lastname}',
                     :order => %w(firstname lastname id),
                     :setting_order => 1
                   },
                 :firstname => {
                     :string => '#{firstname}',
                     :order => %w(firstname id),
                     :setting_order => 2
                   },
                 :lastname_firstname => {
                     :string => '#{lastname} #{firstname}',
                     :order => %w(lastname firstname id),
                     :setting_order => 3
                   },
                 :lastname_coma_firstname => {
                     :string => '#{lastname}, #{firstname}',
                     :order => %w(lastname firstname id),
                     :setting_order => 4
                   },
                 :lastname => {
                     :string => '#{lastname}',
                     :order => %w(lastname id),
                     :setting_order => 5
                   },
                 :username => {
                     :string => '#{login}',
                     :order => %w(login id),
                     :setting_order => 6
                   },
               }
               MAIL_NOTIFICATION_OPTIONS = [
                 ['all', :label_user_mail_option_all],
                 ['selected', :label_user_mail_option_selected],
                 ['only_my_events', :label_user_mail_option_only_my_events],
                 ['only_assigned', :label_user_mail_option_only_assigned],
                 ['only_owner', :label_user_mail_option_only_owner],
                 ['none', :label_user_mail_option_none]
               ]
               has_and_belongs_to_many :groups, :after_add => Proc.new {|user, group| group.user_added(user)},
                                                :after_remove => Proc.new {|user, group| group.user_removed(user)}
               has_many :changesets, :dependent => :nullify
               has_one :preference, :dependent => :destroy, :class_name => 'UserPreference'
               has_one :rss_token, :class_name => 'Token', :conditions => "action='feeds'"
               has_one :api_token, :class_name => 'Token', :conditions => "action='api'"
               belongs_to :auth_source
               scope :logged, :conditions => "#{User.table_name}.status <> #{STATUS_ANONYMOUS}"
               scope :status, lambda {|arg| arg.blank? ? {} : {:conditions => {:status => arg.to_i}} }
               acts_as_customizable
               attr_accessor :password, :password_confirmation
               attr_accessor :last_before_login_on
               # Prevents unauthorized assignments
               attr_protected :login, :admin, :password, :password_confirmation, :hashed_password
               LOGIN_LENGTH_LIMIT = 60
               MAIL_LENGTH_LIMIT = 60
               validates_presence_of :login, :firstname, :lastname, :mail, :if => Proc.new { |user| !user.is_a?(AnonymousUser) }
               validates_uniqueness_of :login, :if => Proc.new { |user| user.login_changed? && user.login.present? }, :case_sensitive => false
               validates_uniqueness_of :mail, :if => Proc.new { |user| !user.mail.blank? }, :case_sensitive => false
               # Login must contain lettres, numbers, underscores only
               validates_format_of :login, :with => /^[a-z0-9_\-@\.]*$/i
               validates_length_of :login, :maximum => LOGIN_LENGTH_LIMIT
               validates_length_of :firstname, :lastname, :maximum => 30
               validates_format_of :mail, :with => /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i, :allow_blank => true
               validates_length_of :mail, :maximum => MAIL_LENGTH_LIMIT, :allow_nil => true
               validates_confirmation_of :password, :allow_nil => true
               validates_inclusion_of :mail_notification, :in => MAIL_NOTIFICATION_OPTIONS.collect(&:first), :allow_blank => true
               validate :validate_password_length
               before_create :set_mail_notification
               before_save   :update_hashed_password
               before_destroy :remove_references_before_destroy
               scope :in_group, lambda {|group|
                 group_id = group.is_a?(Group) ? group.id : group.to_i
                 { :conditions => ["#{User.table_name}.id IN (SELECT gu.user_id FROM #{table_name_prefix}groups_users#{table_name_suffix} gu WHERE gu.group_id = ?)", group_id] }
               }
               scope :not_in_group, lambda {|group|
                 group_id = group.is_a?(Group) ? group.id : group.to_i
                 { :conditions => ["#{User.table_name}.id NOT IN (SELECT gu.user_id FROM #{table_name_prefix}groups_users#{table_name_suffix} gu WHERE gu.group_id = ?)", group_id] }
               }
               def set_mail_notification
                 self.mail_notification = Setting.default_notification_option if self.mail_notification.blank?
                 true
               end
               def update_hashed_password
                 # update hashed_password if password was set
                 if self.password && self.auth_source_id.blank?
                   salt_password(password)
                 end
               end
               def reload(*args)
                 @name = nil
                 @projects_by_role = nil
                 super
               end
               def mail=(arg)
                 write_attribute(:mail, arg.to_s.strip)
               end
               def identity_url=(url)
                 if url.blank?
                   write_attribute(:identity_url, '')
                 else
                   begin
                     write_attribute(:identity_url, OpenIdAuthentication.normalize_identifier(url))
                   rescue OpenIdAuthentication::InvalidOpenId
                     # Invlaid url, don't save
                   end
                 end
                 self.read_attribute(:identity_url)
               end
               # Returns the user that matches provided login and password, or nil
               def self.try_to_login(login, password)
                 login = login.to_s
                 password = password.to_s
                 # Make sure no one can sign in with an empty password
                 return nil if password.empty?
                 user = find_by_login(login)
                 if user
                   # user is already in local database
                   return nil if !user.active?
                   if user.auth_source
                     # user has an external authentication method
                     return nil unless user.auth_source.authenticate(login, password)
                   else
                     # authentication with local password
                     return nil unless user.check_password?(password)
                   end
                 else
                   # user is not yet registered, try to authenticate with available sources
                   attrs = AuthSource.authenticate(login, password)
                   if attrs
                     user = new(attrs)
                     user.login = login
                     user.language = Setting.default_language
                     if user.save
                       user.reload
                       logger.info("User '#{user.login}' created from external auth source: #{user.auth_source.type} - #{user.auth_source.name}") if logger && user.auth_source
                     end
                   end
                 end
                 user.update_attribute(:last_login_on, Time.now) if user && !user.new_record?
                 user
               rescue => text
                 raise text
               end
               # Returns the user who matches the given autologin +key+ or nil
               def self.try_to_autologin(key)
                 tokens = Token.find_all_by_action_and_value('autologin', key.to_s)
                 # Make sure there's only 1 token that matches the key
                 if tokens.size == 1
                   token = tokens.first
                   if (token.created_on > Setting.autologin.to_i.day.ago) && token.user && token.user.active?
                     token.user.update_attribute(:last_login_on, Time.now)
                     token.user
                   end
                 end
               end
               def self.name_formatter(formatter = nil)
                 USER_FORMATS[formatter || Setting.user_format] || USER_FORMATS[:firstname_lastname]
               end
               # Returns an array of fields names than can be used to make an order statement for users
               # according to how user names are displayed
               # Examples:
               #
               #   User.fields_for_order_statement              => ['users.login', 'users.id']
               #   User.fields_for_order_statement('authors')   => ['authors.login', 'authors.id']
               def self.fields_for_order_statement(table=nil)
                 table ||= table_name
                 name_formatter[:order].map {|field| "#{table}.#{field}"}
               end
               # Return user's full name for display
               def name(formatter = nil)
                 f = self.class.name_formatter(formatter)
                 if formatter
                   eval('"' + f[:string] + '"')
                 else
                   @name ||= eval('"' + f[:string] + '"')
                 end
               end
               def active?
                 self.status == STATUS_ACTIVE
               end
               def registered?
                 self.status == STATUS_REGISTERED
               end
               def locked?
                 self.status == STATUS_LOCKED
               end
               def activate
                 self.status = STATUS_ACTIVE
               end
               def register
                 self.status = STATUS_REGISTERED
               end
               def lock
                 self.status = STATUS_LOCKED
               end
               def activate!
                 update_attribute(:status, STATUS_ACTIVE)
               end
               def register!
                 update_attribute(:status, STATUS_REGISTERED)
               end
               def lock!
                 update_attribute(:status, STATUS_LOCKED)
               end
               # Returns true if +clear_password+ is the correct user's password, otherwise false
               def check_password?(clear_password)
                 if auth_source_id.present?
                   auth_source.authenticate(self.login, clear_password)
                 else
                   User.hash_password("#{salt}#{User.hash_password clear_password}") == hashed_password
                 end
               end
               # Generates a random salt and computes hashed_password for +clear_password+
               # The hashed password is stored in the following form: SHA1(salt + SHA1(password))
               def salt_password(clear_password)
                 self.salt = User.generate_salt
                 self.hashed_password = User.hash_password("#{salt}#{User.hash_password clear_password}")
               end
               # Does the backend storage allow this user to change their password?
               def change_password_allowed?
                 return true if auth_source.nil?
                 return auth_source.allow_password_changes?
               end
               # Generate and set a random password.  Useful for automated user creation
               # Based on Token#generate_token_value
               #
               def random_password
                 chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a
                 password = ''
 .times { |i| password << chars[rand(chars.size-1)] }
                 self.password = password
                 self.password_confirmation = password
                 self
               end
               def pref
                 self.preference ||= UserPreference.new(:user => self)
               end
               def time_zone
                 @time_zone ||= (self.pref.time_zone.blank? ? nil : ActiveSupport::TimeZone[self.pref.time_zone])
               end
               def wants_comments_in_reverse_order?
                 self.pref[:comments_sorting] == 'desc'
               end
               # Return user's RSS key (a 40 chars long string), used to access feeds
               def rss_key
                 if rss_token.nil?
                   create_rss_token(:action => 'feeds')
                 end
                 rss_token.value
               end
               # Return user's API key (a 40 chars long string), used to access the API
               def api_key
                 if api_token.nil?
                   create_api_token(:action => 'api')
                 end
                 api_token.value
               end
               # Return an array of project ids for which the user has explicitly turned mail notifications on
               def notified_projects_ids
                 @notified_projects_ids ||= memberships.select {|m| m.mail_notification?}.collect(&:project_id)
               end
               def notified_project_ids=(ids)
                 Member.update_all("mail_notification = #{connection.quoted_false}", ['user_id = ?', id])
                 Member.update_all("mail_notification = #{connection.quoted_true}", ['user_id = ? AND project_id IN (?)', id, ids]) if ids && !ids.empty?
                 @notified_projects_ids = nil
                 notified_projects_ids
               end
               def valid_notification_options
                 self.class.valid_notification_options(self)
               end
               # Only users that belong to more than 1 project can select projects for which they are notified
               def self.valid_notification_options(user=nil)
                 # Note that @user.membership.size would fail since AR ignores
                 # :include association option when doing a count
                 if user.nil? || user.memberships.length < 1
                   MAIL_NOTIFICATION_OPTIONS.reject {|option| option.first == 'selected'}
                 else
                   MAIL_NOTIFICATION_OPTIONS
                 end
               end
               # Find a user account by matching the exact login and then a case-insensitive
               # version.  Exact matches will be given priority.
               def self.find_by_login(login)
                 # First look for an exact match
                 user = all(:conditions => {:login => login}).detect {|u| u.login == login}
                 unless user
                   # Fail over to case-insensitive if none was found
                   user = first(:conditions => ["LOWER(login) = ?", login.to_s.downcase])
                 end
                 user
               end
               def self.find_by_rss_key(key)
                 token = Token.find_by_action_and_value('feeds', key.to_s)
                 token && token.user.active? ? token.user : nil
               end
               def self.find_by_api_key(key)
                 token = Token.find_by_action_and_value('api', key.to_s)
                 token && token.user.active? ? token.user : nil
               end
               # Makes find_by_mail case-insensitive
               def self.find_by_mail(mail)
                 find(:first, :conditions => ["LOWER(mail) = ?", mail.to_s.downcase])
               end
               # Returns true if the default admin account can no longer be used
               def self.default_admin_account_changed?
                 !User.active.find_by_login("admin").try(:check_password?, "admin")
               end
               def to_s
                 name
               end
+              CSS_CLASS_BY_STATUS = {
+                STATUS_ANONYMOUS  => 'anon',
+                STATUS_ACTIVE     => 'active',
+                STATUS_REGISTERED => 'registered',
+                STATUS_LOCKED     => 'locked'
+              }
+              def css_classes
+                "user #{CSS_CLASS_BY_STATUS[status]}"
+              end
               # Returns the current day according to user's time zone
               def today
                 if time_zone.nil?
                   Date.today
                 else
                   Time.now.in_time_zone(time_zone).to_date
                 end
               end
               # Returns the day of +time+ according to user's time zone
               def time_to_date(time)
                 if time_zone.nil?
                   time.to_date
                 else
                   time.in_time_zone(time_zone).to_date
                 end
               end
               def logged?
                 true
               end
               def anonymous?
                 !logged?
               end
               # Return user's roles for project
               def roles_for_project(project)
                 roles = []
                 # No role on archived projects
                 return roles if project.nil? || project.archived?
                 if logged?
                   # Find project membership
                   membership = memberships.detect {|m| m.project_id == project.id}
                   if membership
                     roles = membership.roles
                   else
                     @role_non_member ||= Role.non_member
                     roles << @role_non_member
                   end
                 else
                   @role_anonymous ||= Role.anonymous
                   roles << @role_anonymous
                 end
                 roles
               end
               # Return true if the user is a member of project
               def member_of?(project)
                 !roles_for_project(project).detect {|role| role.member?}.nil?
               end
               # Returns a hash of user's projects grouped by roles
               def projects_by_role
                 return @projects_by_role if @projects_by_role
                 @projects_by_role = Hash.new([])
                 memberships.each do |membership|
                   if membership.project
                     membership.roles.each do |role|
                       @projects_by_role[role] = [] unless @projects_by_role.key?(role)
                       @projects_by_role[role] << membership.project
                     end
                   end
                 end
                 @projects_by_role.each do |role, projects|
                   projects.uniq!
                 end
                 @projects_by_role
               end
               # Returns true if user is arg or belongs to arg
               def is_or_belongs_to?(arg)
                 if arg.is_a?(User)
                   self == arg
                 elsif arg.is_a?(Group)
                   arg.users.include?(self)
                 else
                   false
                 end
               end
               # Return true if the user is allowed to do the specified action on a specific context
               # Action can be:
               # * a parameter-like Hash (eg. :controller => 'projects', :action => 'edit')
               # * a permission Symbol (eg. :edit_project)
               # Context can be:
               # * a project : returns true if user is allowed to do the specified action on this project
               # * an array of projects : returns true if user is allowed on every project
               # * nil with options[:global] set : check if user has at least one role allowed for this action,
               #   or falls back to Non Member / Anonymous permissions depending if the user is logged
               def allowed_to?(action, context, options={}, &block)
                 if context && context.is_a?(Project)
                   return false unless context.allows_to?(action)
                   # Admin users are authorized for anything else
                   return true if admin?
                   roles = roles_for_project(context)
                   return false unless roles
                   roles.any? {|role|
                     (context.is_public? || role.member?) &&
                     role.allowed_to?(action) &&
                     (block_given? ? yield(role, self) : true)
                   }
                 elsif context && context.is_a?(Array)
                   if context.empty?
                     false
                   else
                     # Authorize if user is authorized on every element of the array
                     context.map {|project| allowed_to?(action, project, options, &block)}.reduce(:&)
                   end
                 elsif options[:global]
                   # Admin users are always authorized
                   return true if admin?
                   # authorize if user has at least one role that has this permission
                   roles = memberships.collect {|m| m.roles}.flatten.uniq
                   roles << (self.logged? ? Role.non_member : Role.anonymous)
                   roles.any? {|role|
                     role.allowed_to?(action) &&
                     (block_given? ? yield(role, self) : true)
                   }
                 else
                   false
                 end
               end
               # Is the user allowed to do the specified action on any project?
               # See allowed_to? for the actions and valid options.
               def allowed_to_globally?(action, options, &block)
                 allowed_to?(action, nil, options.reverse_merge(:global => true), &block)
               end
               # Returns true if the user is allowed to delete his own account
               def own_account_deletable?
                 Setting.unsubscribe? &&
                   (!admin? || User.active.first(:conditions => ["admin = ? AND id <> ?", true, id]).present?)
               end
               safe_attributes 'login',
                 'firstname',
                 'lastname',
                 'mail',
                 'mail_notification',
                 'language',
                 'custom_field_values',
                 'custom_fields',
                 'identity_url'
               safe_attributes 'status',
                 'auth_source_id',
                 :if => lambda {|user, current_user| current_user.admin?}
               safe_attributes 'group_ids',
                 :if => lambda {|user, current_user| current_user.admin? && !user.new_record?}
               # Utility method to help check if a user should be notified about an
               # event.
               #
               # TODO: only supports Issue events currently
               def notify_about?(object)
                 case mail_notification
                 when 'all'
                   true
                 when 'selected'
                   # user receives notifications for created/assigned issues on unselected projects
                   if object.is_a?(Issue) && (object.author == self || is_or_belongs_to?(object.assigned_to) || is_or_belongs_to?(object.assigned_to_was))
                     true
                   else
                     false
                   end
                 when 'none'
                   false
                 when 'only_my_events'
                   if object.is_a?(Issue) && (object.author == self || is_or_belongs_to?(object.assigned_to) || is_or_belongs_to?(object.assigned_to_was))
                     true
                   else
                     false
                   end
                 when 'only_assigned'
                   if object.is_a?(Issue) && (is_or_belongs_to?(object.assigned_to) || is_or_belongs_to?(object.assigned_to_was))
                     true
                   else
                     false
                   end
                 when 'only_owner'
                   if object.is_a?(Issue) && object.author == self
                     true
                   else
                     false
                   end
                 else
                   false
                 end
               end
               def self.current=(user)
                 @current_user = user
               end
               def self.current
                 @current_user ||= User.anonymous
               end
               # Returns the anonymous user.  If the anonymous user does not exist, it is created.  There can be only
               # one anonymous user per database.
               def self.anonymous
                 anonymous_user = AnonymousUser.find(:first)
                 if anonymous_user.nil?
                   anonymous_user = AnonymousUser.create(:lastname => 'Anonymous', :firstname => '', :mail => '', :login => '', :status => 0)
                   raise 'Unable to create the anonymous user.' if anonymous_user.new_record?
                 end
                 anonymous_user
               end
               # Salts all existing unsalted passwords
               # It changes password storage scheme from SHA1(password) to SHA1(salt + SHA1(password))
               # This method is used in the SaltPasswords migration and is to be kept as is
               def self.salt_unsalted_passwords!
                 transaction do
                   User.find_each(:conditions => "salt IS NULL OR salt = ''") do |user|
                     next if user.hashed_password.blank?
                     salt = User.generate_salt
                     hashed_password = User.hash_password("#{salt}#{user.hashed_password}")
                     User.update_all("salt = '#{salt}', hashed_password = '#{hashed_password}'", ["id = ?", user.id] )
                   end
                 end
               end
               protected
               def validate_password_length
                 # Password length validation based on setting
                 if !password.nil? && password.size < Setting.password_min_length.to_i
                   errors.add(:password, :too_short, :count => Setting.password_min_length.to_i)
                 end
               end
               private
               # Removes references that are not handled by associations
               # Things that are not deleted are reassociated with the anonymous user
               def remove_references_before_destroy
                 return if self.id.nil?
                 substitute = User.anonymous
                 Attachment.update_all ['author_id = ?', substitute.id], ['author_id = ?', id]
                 Comment.update_all ['author_id = ?', substitute.id], ['author_id = ?', id]
                 Issue.update_all ['author_id = ?', substitute.id], ['author_id = ?', id]
                 Issue.update_all 'assigned_to_id = NULL', ['assigned_to_id = ?', id]
                 Journal.update_all ['user_id = ?', substitute.id], ['user_id = ?', id]
                 JournalDetail.update_all ['old_value = ?', substitute.id.to_s], ["property = 'attr' AND prop_key = 'assigned_to_id' AND old_value = ?", id.to_s]
                 JournalDetail.update_all ['value = ?', substitute.id.to_s], ["property = 'attr' AND prop_key = 'assigned_to_id' AND value = ?", id.to_s]
                 Message.update_all ['author_id = ?', substitute.id], ['author_id = ?', id]
                 News.update_all ['author_id = ?', substitute.id], ['author_id = ?', id]
                 # Remove private queries and keep public ones
                 ::Query.delete_all ['user_id = ? AND is_public = ?', id, false]
                 ::Query.update_all ['user_id = ?', substitute.id], ['user_id = ?', id]
                 TimeEntry.update_all ['user_id = ?', substitute.id], ['user_id = ?', id]
                 Token.delete_all ['user_id = ?', id]
                 Watcher.delete_all ['user_id = ?', id]
                 WikiContent.update_all ['author_id = ?', substitute.id], ['author_id = ?', id]
                 WikiContent::Version.update_all ['author_id = ?', substitute.id], ['author_id = ?', id]
               end
               # Return password digest
               def self.hash_password(clear_password)
                 Digest::SHA1.hexdigest(clear_password || "")
               end
               # Returns a 128bits random salt as a hex string (32 chars long)
               def self.generate_salt
                 Redmine::Utils.random_hex(16)
               end
             end
             class AnonymousUser < User
               validate :validate_anonymous_uniqueness, :on => :create
               def validate_anonymous_uniqueness
                 # There should be only one AnonymousUser in the database
                 errors.add :base, 'An anonymous user already exists.' if AnonymousUser.find(:first)
               end
               def available_custom_fields
                 []
               end
               # Overrides a few properties
               def logged?; false end
               def admin; false end
               def name(*args); I18n.t(:label_user_anonymous) end
               def mail; nil end
               def time_zone; nil end
               def rss_key; nil end
               def pref
                 UserPreference.new(:user => self)
               end
               # Anonymous user can not be destroyed
               def destroy
                 false
               end
             end

app/views/users/index.html.erb +1 -1

             <div class="contextual">
             <%= link_to l(:label_user_new), new_user_path, :class => 'icon icon-add' %>
             </div>
             <h2><%=l(:label_user_plural)%></h2>
             <%= form_tag({}, :method => :get) do %>
             <fieldset><legend><%= l(:label_filter_plural) %></legend>
             <label for='status'><%= l(:field_status) %>:</label>
             <%= select_tag 'status', users_status_options_for_select(@status), :class => "small", :onchange => "this.form.submit(); return false;"  %>
             <% if @groups.present? %>
             <label for='group_id'><%= l(:label_group) %>:</label>
             <%= select_tag 'group_id', content_tag('option') + options_from_collection_for_select(@groups, :id, :name, params[:group_id].to_i), :onchange => "this.form.submit(); return false;"  %>
             <% end %>
             <label for='name'><%= l(:label_user) %>:</label>
             <%= text_field_tag 'name', params[:name], :size => 30 %>
             <%= submit_tag l(:button_apply), :class => "small", :name => nil %>
             <%= link_to l(:button_clear), users_path, :class => 'icon icon-reload' %>
             </fieldset>
             <% end %>
             &nbsp;
             <div class="autoscroll">
             <table class="list">
               <thead><tr>
               <%= sort_header_tag('login', :caption => l(:field_login)) %>
               <%= sort_header_tag('firstname', :caption => l(:field_firstname)) %>
               <%= sort_header_tag('lastname', :caption => l(:field_lastname)) %>
               <%= sort_header_tag('mail', :caption => l(:field_mail)) %>
               <%= sort_header_tag('admin', :caption => l(:field_admin), :default_order => 'desc') %>
               <%= sort_header_tag('created_on', :caption => l(:field_created_on), :default_order => 'desc') %>
               <%= sort_header_tag('last_login_on', :caption => l(:field_last_login_on), :default_order => 'desc') %>
                 <th></th>
               </tr></thead>
               <tbody>
             <% for user in @users -%>
-              <tr class="user <%= cycle("odd", "even") %> <%= %w(anon active registered locked)[user.status] %>">
+              <tr class="<%= user.css_classes %> <%= cycle("odd", "even") %>">
               <td class="username"><%= avatar(user, :size => "14") %><%= link_to h(user.login), edit_user_path(user) %></td>
               <td class="firstname"><%= h(user.firstname) %></td>
               <td class="lastname"><%= h(user.lastname) %></td>
               <td class="email"><%= mail_to(h(user.mail)) %></td>
               <td align="center"><%= checked_image user.admin? %></td>
               <td class="created_on" align="center"><%= format_time(user.created_on) %></td>
               <td class="last_login_on" align="center"><%= format_time(user.last_login_on) unless user.last_login_on.nil? %></td>
                 <td class="buttons">
                   <%= change_status_link(user) %>
                   <%= delete_link user_path(user, :back_url => users_path(params)) unless User.current == user %>
                 </td>
               </tr>
             <% end -%>
               </tbody>
             </table>
             </div>
             <p class="pagination"><%= pagination_links_full @user_pages, @user_count %></p>
             <% html_title(l(:label_user_plural)) -%>

public/stylesheets/application.css +1 0

             html {overflow-y:scroll;}
             body { font-family: Verdana, sans-serif; font-size: 12px; color:#484848; margin: 0; padding: 0; min-width: 900px; }
             h1, h2, h3, h4 {font-family: "Trebuchet MS", Verdana, sans-serif;padding: 2px 10px 1px 0px;margin: 0 0 10px 0;}
             #content h1, h2, h3, h4 {color: #555;}
             h2, .wiki h1 {font-size: 20px;}
             h3, .wiki h2 {font-size: 16px;}
             h4, .wiki h3 {font-size: 13px;}
             h4 {border-bottom: 1px dotted #bbb;}
             /***** Layout *****/
             #wrapper {background: white;}
             #top-menu {background: #3E5B76; color: #fff; height:1.8em; font-size: 0.8em; padding: 2px 2px 0px 6px;}
             #top-menu ul {margin: 0;  padding: 0;}
             #top-menu li {
               float:left;
               list-style-type:none;
               margin: 0px 0px 0px 0px;
               padding: 0px 0px 0px 0px;
               white-space:nowrap;
             }
             #top-menu a {color: #fff; margin-right: 8px; font-weight: bold;}
             #top-menu #loggedas { float: right; margin-right: 0.5em; color: #fff; }
             #account {float:right;}
             #header {height:5.3em;margin:0;background-color:#628DB6;color:#f8f8f8; padding: 4px 8px 0px 6px; position:relative;}
             #header a {color:#f8f8f8;}
             #header h1 a.ancestor { font-size: 80%; }
             #quick-search {float:right;}
             #main-menu {position: absolute;  bottom: 0px;  left:6px; margin-right: -500px;}
             #main-menu ul {margin: 0;  padding: 0;}
             #main-menu li {
               float:left;
               list-style-type:none;
               margin: 0px 2px 0px 0px;
               padding: 0px 0px 0px 0px;
               white-space:nowrap;
             }
             #main-menu li a {
               display: block;
               color: #fff;
               text-decoration: none;
               font-weight: bold;
               margin: 0;
               padding: 4px 10px 4px 10px;
             }
             #main-menu li a:hover {background:#759FCF; color:#fff;}
             #main-menu li a.selected, #main-menu li a.selected:hover {background:#fff; color:#555;}
             #admin-menu ul {margin: 0;  padding: 0;}
             #admin-menu li {margin: 0;  padding: 0 0 6px 0; list-style-type:none;}
             #admin-menu a { background-position: 0% 40%; background-repeat: no-repeat; padding-left: 20px; padding-top: 2px; padding-bottom: 3px;}
             #admin-menu a.projects { background-image: url(../images/projects.png); }
             #admin-menu a.users { background-image: url(../images/user.png); }
             #admin-menu a.groups { background-image: url(../images/group.png); }
             #admin-menu a.roles { background-image: url(../images/database_key.png); }
             #admin-menu a.trackers { background-image: url(../images/ticket.png); }
             #admin-menu a.issue_statuses { background-image: url(../images/ticket_edit.png); }
             #admin-menu a.workflows { background-image: url(../images/ticket_go.png); }
             #admin-menu a.custom_fields { background-image: url(../images/textfield.png); }
             #admin-menu a.enumerations { background-image: url(../images/text_list_bullets.png); }
             #admin-menu a.settings { background-image: url(../images/changeset.png); }
             #admin-menu a.plugins { background-image: url(../images/plugin.png); }
             #admin-menu a.info { background-image: url(../images/help.png); }
             #admin-menu a.server_authentication { background-image: url(../images/server_key.png); }
             #main {background-color:#EEEEEE;}
             #sidebar{ float: right; width: 22%; position: relative; z-index: 9; padding: 0; margin: 0;}
             * html #sidebar{ width: 22%; }
             #sidebar h3{ font-size: 14px; margin-top:14px; color: #666;  }
             #sidebar hr{ width: 100%; margin: 0 auto; height: 1px; background: #ccc; border: 0; }
             * html #sidebar hr{ width: 95%; position: relative; left: -6px; color: #ccc; }
             #sidebar .contextual { margin-right: 1em; }
             #content { width: 75%; background-color: #fff; margin: 0px; border-right: 1px solid #ddd; padding: 6px 10px 10px 10px; z-index: 10; }
             * html #content{ width: 75%; padding-left: 0; margin-top: 0px; padding: 6px 10px 10px 10px;}
             html>body #content { min-height: 600px; }
             * html body #content { height: 600px; } /* IE */
             #main.nosidebar #sidebar{ display: none; }
             #main.nosidebar #content{ width: auto; border-right: 0; }
             #footer {clear: both; border-top: 1px solid #bbb; font-size: 0.9em; color: #aaa; padding: 5px; text-align:center; background:#fff;}
             #login-form table {margin-top:5em; padding:1em; margin-left: auto; margin-right: auto; border: 2px solid #FDBF3B; background-color:#FFEBC1; }
             #login-form table td {padding: 6px;}
             #login-form label {font-weight: bold;}
             #login-form input#username, #login-form input#password { width: 300px; }
             div.modal { border-radius:5px; background:#fff; z-index:50; padding:4px;}
             div.modal h3.title {display:none;}
             div.modal p.buttons {text-align:right; margin-bottom:0;}
             input#openid_url { background: url(../images/openid-bg.gif) no-repeat; background-color: #fff; background-position: 0 50%; padding-left: 18px; }
             .clear:after{ content: "."; display: block; height: 0; clear: both; visibility: hidden; }
             /***** Links *****/
             a, a:link, a:visited{ color: #169; text-decoration: none; }
             a:hover, a:active{ color: #c61a1a; text-decoration: underline;}
             a img{ border: 0; }
             a.issue.closed, a.issue.closed:link, a.issue.closed:visited { color: #999; text-decoration: line-through; }
             a.project.closed, a.project.closed:link, a.project.closed:visited { color: #999; }
+            a.user.locked, a.user.locked:link, a.user.locked:visited {color: #999;}
             #sidebar a.selected {line-height:1.7em; padding:1px 3px 2px 2px; margin-left:-2px; background-color:#9DB9D5; color:#fff; border-radius:2px;}
             #sidebar a.selected:hover {text-decoration:none;}
             #admin-menu a {line-height:1.7em;}
             #admin-menu a.selected {padding-left: 20px !important; background-position: 2px 40%;}
             a.collapsible {padding-left: 12px; background: url(../images/arrow_expanded.png) no-repeat -3px 40%;}
             a.collapsible.collapsed {background: url(../images/arrow_collapsed.png) no-repeat -5px 40%;}
             a#toggle-completed-versions {color:#999;}
             /***** Tables *****/
             table.list { border: 1px solid #e4e4e4;  border-collapse: collapse; width: 100%; margin-bottom: 4px; }
             table.list th {  background-color:#EEEEEE; padding: 4px; white-space:nowrap; }
             table.list td { vertical-align: top; padding-right:10px; }
             table.list td.id { width: 2%; text-align: center;}
             table.list td.checkbox { width: 15px; padding: 2px 0 0 0; }
             table.list td.checkbox input {padding:0px;}
             table.list td.buttons { width: 15%; white-space:nowrap; text-align: right; }
             table.list td.buttons a { padding-right: 0.6em; }
             table.list caption { text-align: left; padding: 0.5em 0.5em 0.5em 0; }
             tr.project td.name a { white-space:nowrap; }
             tr.project.closed, tr.project.archived { color: #aaa; }
             tr.project.closed a, tr.project.archived a { color: #aaa; }
             tr.project.idnt td.name span {background: url(../images/bullet_arrow_right.png) no-repeat 0 50%; padding-left: 16px;}
             tr.project.idnt-1 td.name {padding-left: 0.5em;}
             tr.project.idnt-2 td.name {padding-left: 2em;}
             tr.project.idnt-3 td.name {padding-left: 3.5em;}
             tr.project.idnt-4 td.name {padding-left: 5em;}
             tr.project.idnt-5 td.name {padding-left: 6.5em;}
             tr.project.idnt-6 td.name {padding-left: 8em;}
             tr.project.idnt-7 td.name {padding-left: 9.5em;}
             tr.project.idnt-8 td.name {padding-left: 11em;}
             tr.project.idnt-9 td.name {padding-left: 12.5em;}
             tr.issue { text-align: center; white-space: nowrap; }
             tr.issue td.subject, tr.issue td.category, td.assigned_to, tr.issue td.string, tr.issue td.text, tr.issue td.relations { white-space: normal; }
             tr.issue td.subject, tr.issue td.relations { text-align: left; }
             tr.issue td.done_ratio table.progress { margin-left:auto; margin-right: auto;}
             tr.issue td.relations span {white-space: nowrap;}
             tr.issue.idnt td.subject a {background: url(../images/bullet_arrow_right.png) no-repeat 0 50%; padding-left: 16px;}
             tr.issue.idnt-1 td.subject {padding-left: 0.5em;}
             tr.issue.idnt-2 td.subject {padding-left: 2em;}
             tr.issue.idnt-3 td.subject {padding-left: 3.5em;}
             tr.issue.idnt-4 td.subject {padding-left: 5em;}
             tr.issue.idnt-5 td.subject {padding-left: 6.5em;}
             tr.issue.idnt-6 td.subject {padding-left: 8em;}
             tr.issue.idnt-7 td.subject {padding-left: 9.5em;}
             tr.issue.idnt-8 td.subject {padding-left: 11em;}
             tr.issue.idnt-9 td.subject {padding-left: 12.5em;}
             tr.entry { border: 1px solid #f8f8f8; }
             tr.entry td { white-space: nowrap; }
             tr.entry td.filename { width: 30%; }
             tr.entry td.filename_no_report { width: 70%; }
             tr.entry td.size { text-align: right; font-size: 90%; }
             tr.entry td.revision, tr.entry td.author { text-align: center; }
             tr.entry td.age { text-align: right; }
             tr.entry.file td.filename a { margin-left: 16px; }
             tr.entry.file td.filename_no_report a { margin-left: 16px; }
             tr span.expander {background-image: url(../images/bullet_toggle_plus.png); padding-left: 8px; margin-left: 0; cursor: pointer;}
             tr.open span.expander {background-image: url(../images/bullet_toggle_minus.png);}
             tr.changeset { height: 20px }
             tr.changeset ul, ol { margin-top: 0px; margin-bottom: 0px; }
             tr.changeset td.revision_graph { width: 15%; background-color: #fffffb; }
             tr.changeset td.author { text-align: center; width: 15%; white-space:nowrap;}
             tr.changeset td.committed_on { text-align: center; width: 15%; white-space:nowrap;}
             table.files tr.file td { text-align: center; }
             table.files tr.file td.filename { text-align: left; padding-left: 24px; }
             table.files tr.file td.digest { font-size: 80%; }
             table.members td.roles, table.memberships td.roles { width: 45%; }
             tr.message { height: 2.6em; }
             tr.message td.subject { padding-left: 20px; }
             tr.message td.created_on { white-space: nowrap; }
             tr.message td.last_message { font-size: 80%; white-space: nowrap; }
             tr.message.locked td.subject { background: url(../images/locked.png) no-repeat 0 1px; }
             tr.message.sticky td.subject { background: url(../images/bullet_go.png) no-repeat 0 1px; font-weight: bold; }
             tr.version.closed, tr.version.closed a { color: #999; }
             tr.version td.name { padding-left: 20px; }
             tr.version.shared td.name { background: url(../images/link.png) no-repeat 0% 70%; }
             tr.version td.date, tr.version td.status, tr.version td.sharing { text-align: center; white-space:nowrap; }
             tr.user td { width:13%; }
             tr.user td.email { width:18%; }
             tr.user td { white-space: nowrap; }
             tr.user.locked, tr.user.registered { color: #aaa; }
             tr.user.locked a, tr.user.registered a { color: #aaa; }
             table.permissions td.role {color:#999;font-size:90%;font-weight:normal !important;text-align:center;vertical-align:bottom;}
             tr.wiki-page-version td.updated_on, tr.wiki-page-version td.author {text-align:center;}
             tr.time-entry { text-align: center; white-space: nowrap; }
             tr.time-entry td.subject, tr.time-entry td.comments { text-align: left; white-space: normal; }
             td.hours { text-align: right; font-weight: bold; padding-right: 0.5em; }
             td.hours .hours-dec { font-size: 0.9em; }
             table.plugins td { vertical-align: middle; }
             table.plugins td.configure { text-align: right; padding-right: 1em; }
             table.plugins span.name { font-weight: bold; display: block; margin-bottom: 6px; }
             table.plugins span.description { display: block; font-size: 0.9em; }
             table.plugins span.url { display: block; font-size: 0.9em; }
             table.list tbody tr.group td { padding: 0.8em 0 0.5em 0.3em; font-weight: bold; border-bottom: 1px solid #ccc; }
             table.list tbody tr.group span.count {position:relative; top:-1px; color:#fff; font-size:10px; background:#9DB9D5; padding:0px 6px 1px 6px; border-radius:3px; margin-left:4px;}
             tr.group a.toggle-all { color: #aaa; font-size: 80%; font-weight: normal; display:none;}
             tr.group:hover a.toggle-all { display:inline;}
             a.toggle-all:hover {text-decoration:none;}
             table.list tbody tr:hover { background-color:#ffffdd; }
             table.list tbody tr.group:hover { background-color:inherit; }
             table td {padding:2px;}
             table p {margin:0;}
             .odd {background-color:#f6f7f8;}
             .even {background-color: #fff;}
             a.sort { padding-right: 16px; background-position: 100% 50%; background-repeat: no-repeat; }
             a.sort.asc  { background-image: url(../images/sort_asc.png); }
             a.sort.desc { background-image: url(../images/sort_desc.png); }
             table.attributes { width: 100% }
             table.attributes th { vertical-align: top; text-align: left; }
             table.attributes td { vertical-align: top; }
             table.boards a.board, h3.comments { background: url(../images/comment.png) no-repeat 0% 50%; padding-left: 20px; }
             table.boards td.topic-count, table.boards td.message-count {text-align:center;}
             table.boards td.last-message {font-size:80%;}
             table.messages td.author, table.messages td.created_on, table.messages td.reply-count {text-align:center;}
             table.query-columns {
               border-collapse: collapse;
               border: 0;
             }
             table.query-columns td.buttons {
               vertical-align: middle;
               text-align: center;
             }
             td.center {text-align:center;}
             h3.version { background: url(../images/package.png) no-repeat 0% 50%; padding-left: 20px; }
             div.issues h3 { background: url(../images/ticket.png) no-repeat 0% 50%; padding-left: 20px; }
             div.members h3 { background: url(../images/group.png) no-repeat 0% 50%; padding-left: 20px; }
             div.news h3 { background: url(../images/news.png) no-repeat 0% 50%; padding-left: 20px; }
             div.projects h3 { background: url(../images/projects.png) no-repeat 0% 50%; padding-left: 20px; }
             #watchers ul {margin: 0;  padding: 0;}
             #watchers li {list-style-type:none;margin: 0px 2px 0px 0px; padding: 0px 0px 0px 0px;}
             #watchers select {width: 95%; display: block;}
             #watchers a.delete {opacity: 0.4;}
             #watchers a.delete:hover {opacity: 1;}
             #watchers img.gravatar {margin: 0 4px 2px 0;}
             span#watchers_inputs {overflow:auto; display:block;}
             span.search_for_watchers {display:block;}
             span.search_for_watchers, span.add_attachment {font-size:80%; line-height:2.5em;}
             span.search_for_watchers a, span.add_attachment a {padding-left:16px; background: url(../images/bullet_add.png) no-repeat 0 50%; }
             .highlight { background-color: #FCFD8D;}
             .highlight.token-1 { background-color: #faa;}
             .highlight.token-2 { background-color: #afa;}
             .highlight.token-3 { background-color: #aaf;}
             .box{
               padding:6px;
               margin-bottom: 10px;
               background-color:#f6f6f6;
               color:#505050;
               line-height:1.5em;
               border: 1px solid #e4e4e4;
             }
             div.square {
               border: 1px solid #999;
               float: left;
               margin: .3em .4em 0 .4em;
               overflow: hidden;
               width: .6em; height: .6em;
             }
             .contextual {float:right; white-space: nowrap; line-height:1.4em;margin-top:5px; padding-left: 10px; font-size:0.9em;}
             .contextual input, .contextual select {font-size:0.9em;}
             .message .contextual { margin-top: 0; }
             .splitcontent {overflow:auto;}
             .splitcontentleft{float:left; width:49%;}
             .splitcontentright{float:right; width:49%;}
             form {display: inline;}
             input, select {vertical-align: middle; margin-top: 1px; margin-bottom: 1px;}
             fieldset {border: 1px solid #e4e4e4; margin:0;}
             legend {color: #484848;}
             hr { width: 100%; height: 1px; background: #ccc; border: 0;}
             blockquote { font-style: italic; border-left: 3px solid #e0e0e0; padding-left: 0.6em; margin-left: 2.4em;}
             blockquote blockquote { margin-left: 0;}
             acronym  { border-bottom: 1px dotted; cursor: help; }
             textarea.wiki-edit { width: 99%; }
             li p {margin-top: 0;}
             div.issue {background:#ffffdd; padding:6px; margin-bottom:6px;border: 1px solid #d7d7d7;}
             p.breadcrumb { font-size: 0.9em; margin: 4px 0 4px 0;}
             p.subtitle { font-size: 0.9em; margin: -6px 0 12px 0; font-style: italic; }
             p.footnote { font-size: 0.9em; margin-top: 0px; margin-bottom: 0px; }
             div.issue div.subject div div { padding-left: 16px; }
             div.issue div.subject p {margin: 0; margin-bottom: 0.1em; font-size: 90%; color: #999;}
             div.issue div.subject>div>p { margin-top: 0.5em; }
             div.issue div.subject h3 {margin: 0; margin-bottom: 0.1em;}
             div.issue span.private { position:relative; bottom: 2px; text-transform: uppercase; background: #d22; color: #fff; font-weight:bold; padding: 0px 2px 0px 2px; font-size: 60%; margin-right: 2px; border-radius: 2px;}
             div.issue .next-prev-links {color:#999;}
             div.issue table.attributes th {width:22%;}
             div.issue table.attributes td {width:28%;}
             #issue_tree table.issues, #relations table.issues { border: 0; }
             #issue_tree td.checkbox, #relations td.checkbox {display:none;}
             #relations td.buttons {padding:0;}
             fieldset.collapsible { border-width: 1px 0 0 0; font-size: 0.9em; }
             fieldset.collapsible legend { padding-left: 16px; background: url(../images/arrow_expanded.png) no-repeat 0% 40%; cursor:pointer; }
             fieldset.collapsible.collapsed legend { background-image: url(../images/arrow_collapsed.png); }
             fieldset#date-range p { margin: 2px 0 2px 0; }
             fieldset#filters table { border-collapse: collapse; }
             fieldset#filters table td { padding: 0; vertical-align: middle; }
             fieldset#filters tr.filter { height: 2.1em; }
             fieldset#filters td.field { width:230px; }
             fieldset#filters td.operator { width:180px; }
             fieldset#filters td.operator select {max-width:170px;}
             fieldset#filters td.values { white-space:nowrap; }
             fieldset#filters td.values select {min-width:130px;}
             fieldset#filters td.values input {height:1em;}
             fieldset#filters td.add-filter { text-align: right; vertical-align: top; }
             .toggle-multiselect {background: url(../images/bullet_toggle_plus.png) no-repeat 0% 40%; padding-left:8px; margin-left:0; cursor:pointer;}
             .buttons { font-size: 0.9em; margin-bottom: 1.4em; margin-top: 1em; }
             div#issue-changesets {float:right; width:45%; margin-left: 1em; margin-bottom: 1em; background: #fff; padding-left: 1em; font-size: 90%;}
             div#issue-changesets div.changeset { padding: 4px;}
             div#issue-changesets div.changeset { border-bottom: 1px solid #ddd; }
             div#issue-changesets p { margin-top: 0; margin-bottom: 1em;}
             .journal ul.details img {margin:0 0 -3px 4px;}
             div.journal {overflow:auto;}
             div.journal.private-notes {border-left:2px solid #d22; padding-left:4px; margin-left:-6px;}
             div#activity dl, #search-results { margin-left: 2em; }
             div#activity dd, #search-results dd { margin-bottom: 1em; padding-left: 18px; font-size: 0.9em; }
             div#activity dt, #search-results dt { margin-bottom: 0px; padding-left: 20px; line-height: 18px; background-position: 0 50%; background-repeat: no-repeat; }
             div#activity dt.me .time { border-bottom: 1px solid #999; }
             div#activity dt .time { color: #777; font-size: 80%; }
             div#activity dd .description, #search-results dd .description { font-style: italic; }
             div#activity span.project:after, #search-results span.project:after { content: " -"; }
             div#activity dd span.description, #search-results dd span.description { display:block; color: #808080; }
             #search-results dd { margin-bottom: 1em; padding-left: 20px; margin-left:0px; }
             div#search-results-counts {float:right;}
             div#search-results-counts ul { margin-top: 0.5em; }
             div#search-results-counts  li { list-style-type:none; float: left; margin-left: 1em; }
             dt.issue { background-image: url(../images/ticket.png); }
             dt.issue-edit { background-image: url(../images/ticket_edit.png); }
             dt.issue-closed { background-image: url(../images/ticket_checked.png); }
             dt.issue-note { background-image: url(../images/ticket_note.png); }
             dt.changeset { background-image: url(../images/changeset.png); }
             dt.news { background-image: url(../images/news.png); }
             dt.message { background-image: url(../images/message.png); }
             dt.reply { background-image: url(../images/comments.png); }
             dt.wiki-page { background-image: url(../images/wiki_edit.png); }
             dt.attachment { background-image: url(../images/attachment.png); }
             dt.document { background-image: url(../images/document.png); }
             dt.project { background-image: url(../images/projects.png); }
             dt.time-entry { background-image: url(../images/time.png); }
             #search-results dt.issue.closed { background-image: url(../images/ticket_checked.png); }
             div#roadmap .related-issues { margin-bottom: 1em; }
             div#roadmap .related-issues td.checkbox { display: none; }
             div#roadmap .wiki h1:first-child { display: none; }
             div#roadmap .wiki h1 { font-size: 120%; }
             div#roadmap .wiki h2 { font-size: 110%; }
             body.controller-versions.action-show div#roadmap .related-issues {width:70%;}
             div#version-summary { float:right; width:28%; margin-left: 16px; margin-bottom: 16px; background-color: #fff; }
             div#version-summary fieldset { margin-bottom: 1em; }
             div#version-summary fieldset.time-tracking table { width:100%; }
             div#version-summary th, div#version-summary td.total-hours { text-align: right; }
             table#time-report td.hours, table#time-report th.period, table#time-report th.total { text-align: right; padding-right: 0.5em; }
             table#time-report tbody tr.subtotal { font-style: italic; color:#777;}
             table#time-report tbody tr.subtotal td.hours { color:#b0b0b0; }
             table#time-report tbody tr.total { font-weight: bold; background-color:#EEEEEE; border-top:1px solid #e4e4e4;}
             table#time-report .hours-dec { font-size: 0.9em; }
             div.wiki-page .contextual a {opacity: 0.4}
             div.wiki-page .contextual a:hover {opacity: 1}
             form .attributes select { width: 60%; }
             input#issue_subject { width: 99%; }
             select#issue_done_ratio { width: 95px; }
             ul.projects {margin:0; padding-left:1em;}
             ul.projects ul {padding-left:1.6em;}
             ul.projects.root {margin:0; padding:0;}
             ul.projects li {list-style-type:none;}
             #projects-index ul.projects ul.projects { border-left: 3px solid #e0e0e0; padding-left:1em;}
             #projects-index ul.projects li.root {margin-bottom: 1em;}
             #projects-index ul.projects li.child {margin-top: 1em;}
             #projects-index ul.projects div.root a.project { font-family: "Trebuchet MS", Verdana, sans-serif; font-weight: bold; font-size: 16px; margin: 0 0 10px 0; }
             .my-project { padding-left: 18px; background: url(../images/fav.png) no-repeat 0 50%; }
             #notified-projects ul, #tracker_project_ids ul {max-height:250px; overflow-y:auto;}
             #related-issues li img {vertical-align:middle;}
             ul.properties {padding:0; font-size: 0.9em; color: #777;}
             ul.properties li {list-style-type:none;}
             ul.properties li span {font-style:italic;}
             .total-hours { font-size: 110%; font-weight: bold; }
             .total-hours span.hours-int { font-size: 120%; }
             .autoscroll {overflow-x: auto; padding:1px; margin-bottom: 1.2em;}
             #user_login, #user_firstname, #user_lastname, #user_mail, #my_account_form select, #user_form select, #user_identity_url { width: 90%; }
             #workflow_copy_form select { width: 200px; }
             table.transitions td.enabled {background: #bfb;}
             table.fields_permissions select {font-size:90%}
             table.fields_permissions td.readonly {background:#ddd;}
             table.fields_permissions td.required {background:#d88;}
             textarea#custom_field_possible_values {width: 99%}
             input#content_comments {width: 99%}
             .pagination {font-size: 90%}
             p.pagination {margin-top:8px;}
             /***** Tabular forms ******/
             .tabular p{
               margin: 0;
               padding: 3px 0 3px 0;
               padding-left: 180px; /* width of left column containing the label elements */
               min-height: 1.8em;
               clear:left;
             }
             html>body .tabular p {overflow:hidden;}
             .tabular label{
               font-weight: bold;
               float: left;
               text-align: right;
               /* width of left column */
               margin-left: -180px;
               /* width of labels. Should be smaller than left column to create some right margin */
               width: 175px;
             }
             .tabular label.floating{
               font-weight: normal;
               margin-left: 0px;
               text-align: left;
               width: 270px;
             }
             .tabular label.block{
               font-weight: normal;
               margin-left: 0px !important;
               text-align: left;
               float: none;
               display: block;
               width: auto;
             }
             .tabular label.inline{
               float:none;
               margin-left: 5px !important;
               width: auto;
             }
             label.no-css {
               font-weight: inherit;
               float:none;
               text-align:left;
               margin-left:0px;
               width:auto;
             }
             input#time_entry_comments { width: 90%;}
             #preview fieldset {margin-top: 1em; background: url(../images/draft.png)}
             .tabular.settings p{ padding-left: 300px; }
             .tabular.settings label{ margin-left: -300px; width: 295px; }
             .tabular.settings textarea { width: 99%; }
             .settings.enabled_scm table {width:100%}
             .settings.enabled_scm td.scm_name{ font-weight: bold; }
             fieldset.settings label { display: block; }
             fieldset#notified_events .parent { padding-left: 20px; }
             span.required {color: #bb0000;}
             .summary {font-style: italic;}
             #attachments_fields input.description {margin-left: 8px; width:340px;}
             #attachments_fields span {display:block; white-space:nowrap;}
             #attachments_fields img {vertical-align: middle;}
             div.attachments { margin-top: 12px; }
             div.attachments p { margin:4px 0 2px 0; }
             div.attachments img { vertical-align: middle; }
             div.attachments span.author { font-size: 0.9em; color: #888; }
             div.thumbnails {margin-top:0.6em;}
             div.thumbnails div {background:#fff;border:2px solid #ddd;display:inline-block;margin-right:2px;}
             div.thumbnails img {margin: 3px;}
             p.other-formats { text-align: right; font-size:0.9em; color: #666; }
             .other-formats span + span:before { content: "| "; }
             a.atom { background: url(../images/feed.png) no-repeat 1px 50%; padding: 2px 0px 3px 16px; }
             em.info {font-style:normal;font-size:90%;color:#888;display:block;}
             em.info.error {padding-left:20px; background:url(../images/exclamation.png) no-repeat 0 50%;}
             textarea.text_cf {width:90%;}
             /* Project members tab */
             div#tab-content-members .splitcontentleft, div#tab-content-memberships .splitcontentleft, div#tab-content-users .splitcontentleft { width: 64% }
             div#tab-content-members .splitcontentright, div#tab-content-memberships .splitcontentright, div#tab-content-users .splitcontentright { width: 34% }
             div#tab-content-members fieldset, div#tab-content-memberships fieldset, div#tab-content-users fieldset { padding:1em; margin-bottom: 1em; }
             div#tab-content-members fieldset legend, div#tab-content-memberships fieldset legend, div#tab-content-users fieldset legend { font-weight: bold; }
             div#tab-content-members fieldset label, div#tab-content-memberships fieldset label, div#tab-content-users fieldset label { display: block; }
             div#tab-content-members fieldset div, div#tab-content-users fieldset div { max-height: 400px; overflow:auto; }
             #users_for_watcher {height: 200px; overflow:auto;}
             #users_for_watcher label {display: block;}
             table.members td.group { padding-left: 20px; background: url(../images/group.png) no-repeat 0% 50%; }
             input#principal_search, input#user_search {width:100%}
             input#principal_search, input#user_search {
               background: url(../images/magnifier.png) no-repeat 2px 50%; padding-left:20px;
               border:1px solid #9EB1C2; border-radius:3px; height:1.5em; width:95%;
             }
             input#principal_search.ajax-loading, input#user_search.ajax-loading {
               background-image: url(../images/loading.gif);
             }
             * html div#tab-content-members fieldset div { height: 450px; }
             /***** Flash & error messages ****/
             #errorExplanation, div.flash, .nodata, .warning, .conflict {
               padding: 4px 4px 4px 30px;
               margin-bottom: 12px;
               font-size: 1.1em;
               border: 2px solid;
             }
             div.flash {margin-top: 8px;}
             div.flash.error, #errorExplanation {
               background: url(../images/exclamation.png) 8px 50% no-repeat;
               background-color: #ffe3e3;
               border-color: #dd0000;
               color: #880000;
             }
             div.flash.notice {
               background: url(../images/true.png) 8px 5px no-repeat;
               background-color: #dfffdf;
               border-color: #9fcf9f;
               color: #005f00;
             }
             div.flash.warning, .conflict {
               background: url(../images/warning.png) 8px 5px no-repeat;
               background-color: #FFEBC1;
               border-color: #FDBF3B;
               color: #A6750C;
               text-align: left;
             }
             .nodata, .warning {
               text-align: center;
               background-color: #FFEBC1;
               border-color: #FDBF3B;
               color: #A6750C;
             }
             #errorExplanation ul { font-size: 0.9em;}
             #errorExplanation h2, #errorExplanation p { display: none; }
             .conflict-details {font-size:80%;}
             /***** Ajax indicator ******/
             #ajax-indicator {
             position: absolute; /* fixed not supported by IE */
             background-color:#eee;
             border: 1px solid #bbb;
             top:35%;
             left:40%;
             width:20%;
             font-weight:bold;
             text-align:center;
             padding:0.6em;
             z-index:100;
             opacity: 0.5;
             }
             html>body #ajax-indicator { position: fixed; }
             #ajax-indicator span {
             background-position: 0% 40%;
             background-repeat: no-repeat;
             background-image: url(../images/loading.gif);
             padding-left: 26px;
             vertical-align: bottom;
             }
             /***** Calendar *****/
             table.cal {border-collapse: collapse; width: 100%; margin: 0px 0 6px 0;border: 1px solid #d7d7d7;}
             table.cal thead th {width: 14%; background-color:#EEEEEE; padding: 4px; }
             table.cal thead th.week-number {width: auto;}
             table.cal tbody tr {height: 100px;}
             table.cal td {border: 1px solid #d7d7d7; vertical-align: top; font-size: 0.9em;}
             table.cal td.week-number { background-color:#EEEEEE; padding: 4px; border:none; font-size: 1em;}
             table.cal td p.day-num {font-size: 1.1em; text-align:right;}
             table.cal td.odd p.day-num {color: #bbb;}
             table.cal td.today {background:#ffffdd;}
             table.cal td.today p.day-num {font-weight: bold;}
             table.cal .starting a, p.cal.legend .starting {background: url(../images/bullet_go.png) no-repeat -1px -2px; padding-left:16px;}
             table.cal .ending a, p.cal.legend .ending {background: url(../images/bullet_end.png) no-repeat -1px -2px; padding-left:16px;}
             table.cal .starting.ending a, p.cal.legend .starting.ending {background: url(../images/bullet_diamond.png) no-repeat -1px -2px; padding-left:16px;}
             p.cal.legend span {display:block;}
             /***** Tooltips ******/
             .tooltip{position:relative;z-index:24;}
             .tooltip:hover{z-index:25;color:#000;}
             .tooltip span.tip{display: none; text-align:left;}
             div.tooltip:hover span.tip{
             display:block;
             position:absolute;
             top:12px; left:24px; width:270px;
             border:1px solid #555;
             background-color:#fff;
             padding: 4px;
             font-size: 0.8em;
             color:#505050;
             }
             img.ui-datepicker-trigger {
               cursor: pointer;
               vertical-align: middle;
               margin-left: 4px;
             }
             /***** Progress bar *****/
             table.progress {
               border-collapse: collapse;
               border-spacing: 0pt;
               empty-cells: show;
               text-align: center;
               float:left;
               margin: 1px 6px 1px 0px;
             }
             table.progress td { height: 1em; }
             table.progress td.closed { background: #BAE0BA none repeat scroll 0%; }
             table.progress td.done { background: #D3EDD3 none repeat scroll 0%; }
             table.progress td.todo { background: #eee none repeat scroll 0%; }
             p.pourcent {font-size: 80%;}
             p.progress-info {clear: left; font-size: 80%; margin-top:-4px; color:#777;}
             #roadmap table.progress td { height: 1.2em; }
             /***** Tabs *****/
             #content .tabs {height: 2.6em; margin-bottom:1.2em; position:relative; overflow:hidden;}
             #content .tabs ul {margin:0; position:absolute; bottom:0; padding-left:0.5em; width: 2000px; border-bottom: 1px solid #bbbbbb;}
             #content .tabs ul li {
               float:left;
               list-style-type:none;
               white-space:nowrap;
               margin-right:4px;
               background:#fff;
               position:relative;
               margin-bottom:-1px;
             }
             #content .tabs ul li a{
               display:block;
               font-size: 0.9em;
               text-decoration:none;
               line-height:1.3em;
               padding:4px 6px 4px 6px;
               border: 1px solid #ccc;
               border-bottom: 1px solid #bbbbbb;
               background-color: #f6f6f6;
               color:#999;
               font-weight:bold;
               border-top-left-radius:3px;
               border-top-right-radius:3px;
             }
             #content .tabs ul li a:hover {
               background-color: #ffffdd;
               text-decoration:none;
             }
             #content .tabs ul li a.selected {
               background-color: #fff;
               border: 1px solid #bbbbbb;
               border-bottom: 1px solid #fff;
               color:#444;
             }
             #content .tabs ul li a.selected:hover {background-color: #fff;}
             div.tabs-buttons { position:absolute; right: 0; width: 48px; height: 24px; background: white; bottom: 0; border-bottom: 1px solid #bbbbbb; }
             button.tab-left, button.tab-right {
               font-size: 0.9em;
               cursor: pointer;
               height:24px;
               border: 1px solid #ccc;
               border-bottom: 1px solid #bbbbbb;
               position:absolute;
               padding:4px;
               width: 20px;
               bottom: -1px;
             }
             button.tab-left {
               right: 20px;
               background: #eeeeee url(../images/bullet_arrow_left.png) no-repeat 50% 50%;
               border-top-left-radius:3px;
             }
             button.tab-right {
               right: 0;
               background: #eeeeee url(../images/bullet_arrow_right.png) no-repeat 50% 50%;
               border-top-right-radius:3px;
             }
             /***** Diff *****/
             .diff_out { background: #fcc; }
             .diff_out span { background: #faa; }
             .diff_in { background: #cfc; }
             .diff_in span { background: #afa; }
             .text-diff {
               padding: 1em;
               background-color:#f6f6f6;
               color:#505050;
               border: 1px solid #e4e4e4;
             }
             /***** Wiki *****/
             div.wiki table {
               border-collapse: collapse;
               margin-bottom: 1em;
             }
             div.wiki table, div.wiki td, div.wiki th {
               border: 1px solid #bbb;
               padding: 4px;
             }
             div.wiki .noborder, div.wiki .noborder td, div.wiki .noborder th {border:0;}
             div.wiki .external {
               background-position: 0% 60%;
               background-repeat: no-repeat;
               padding-left: 12px;
               background-image: url(../images/external.png);
             }
             div.wiki a.new {color: #b73535;}
             div.wiki ul, div.wiki ol {margin-bottom:1em;}
             div.wiki pre {
               margin: 1em 1em 1em 1.6em;
               padding: 8px;
               background-color: #fafafa;
               border: 1px solid #e2e2e2;
               width:auto;
               overflow-x: auto;
               overflow-y: hidden;
             }
             div.wiki ul.toc {
               background-color: #ffffdd;
               border: 1px solid #e4e4e4;
               padding: 4px;
               line-height: 1.2em;
               margin-bottom: 12px;
               margin-right: 12px;
               margin-left: 0;
               display: table
             }
             * html div.wiki ul.toc { width: 50%; } /* IE6 doesn't autosize div */
             div.wiki ul.toc.right { float: right; margin-left: 12px; margin-right: 0; width: auto; }
             div.wiki ul.toc.left  { float: left; margin-right: 12px; margin-left: 0; width: auto; }
             div.wiki ul.toc ul { margin: 0; padding: 0; }
             div.wiki ul.toc li {list-style-type:none; margin: 0; font-size:12px;}
             div.wiki ul.toc li li {margin-left: 1.5em; font-size:10px;}
             div.wiki ul.toc a {
               font-size: 0.9em;
               font-weight: normal;
               text-decoration: none;
               color: #606060;
             }
             div.wiki ul.toc a:hover { color: #c61a1a; text-decoration: underline;}
             a.wiki-anchor { display: none; margin-left: 6px; text-decoration: none; }
             a.wiki-anchor:hover { color: #aaa !important; text-decoration: none; }
             h1:hover a.wiki-anchor, h2:hover a.wiki-anchor, h3:hover a.wiki-anchor { display: inline; color: #ddd; }
             div.wiki img { vertical-align: middle; }
             /***** My page layout *****/
             .block-receiver {
               border:1px dashed #c0c0c0;
               margin-bottom: 20px;
               padding: 15px 0 15px 0;
             }
             .mypage-box {
               margin:0 0 20px 0;
               color:#505050;
               line-height:1.5em;
             }
             .handle {cursor: move;}
             a.close-icon {
               display:block;
               margin-top:3px;
               overflow:hidden;
               width:12px;
               height:12px;
               background-repeat: no-repeat;
               cursor:pointer;
               background-image:url('../images/close.png');
             }
             a.close-icon:hover {background-image:url('../images/close_hl.png');}
             /***** Gantt chart *****/
             .gantt_hdr {
               position:absolute;
               top:0;
               height:16px;
               border-top: 1px solid #c0c0c0;
               border-bottom: 1px solid #c0c0c0;
               border-right: 1px solid #c0c0c0;
               text-align: center;
               overflow: hidden;
             }
             .gantt_subjects { font-size: 0.8em; }
             .gantt_subjects div { line-height:16px;height:16px;overflow:hidden;white-space:nowrap;text-overflow: ellipsis; }
             .task {
               position: absolute;
               height:8px;
               font-size:0.8em;
               color:#888;
               padding:0;
               margin:0;
               line-height:16px;
               white-space:nowrap;
             }
             .task.label {width:100%;}
             .task.label.project, .task.label.version { font-weight: bold; }
             .task_late { background:#f66 url(../images/task_late.png); border: 1px solid #f66; }
             .task_done { background:#00c600 url(../images/task_done.png); border: 1px solid #00c600; }
             .task_todo { background:#aaa url(../images/task_todo.png); border: 1px solid #aaa; }
             .task_todo.parent { background: #888; border: 1px solid #888; height: 3px;}
             .task_late.parent, .task_done.parent { height: 3px;}
             .task.parent.marker.starting  { position: absolute; background: url(../images/task_parent_end.png) no-repeat 0 0; width: 8px; height: 16px; margin-left: -4px; left: 0px; top: -1px;}
             .task.parent.marker.ending { position: absolute; background: url(../images/task_parent_end.png) no-repeat 0 0; width: 8px; height: 16px; margin-left: -4px; right: 0px; top: -1px;}
             .version.task_late { background:#f66 url(../images/milestone_late.png); border: 1px solid #f66; height: 2px; margin-top: 3px;}
             .version.task_done { background:#00c600 url(../images/milestone_done.png); border: 1px solid #00c600; height: 2px; margin-top: 3px;}
             .version.task_todo { background:#fff url(../images/milestone_todo.png); border: 1px solid #fff; height: 2px; margin-top: 3px;}
             .version.marker { background-image:url(../images/version_marker.png); background-repeat: no-repeat; border: 0; margin-left: -4px; margin-top: 1px; }
             .project.task_late { background:#f66 url(../images/milestone_late.png); border: 1px solid #f66; height: 2px; margin-top: 3px;}
             .project.task_done { background:#00c600 url(../images/milestone_done.png); border: 1px solid #00c600; height: 2px; margin-top: 3px;}
             .project.task_todo { background:#fff url(../images/milestone_todo.png); border: 1px solid #fff; height: 2px; margin-top: 3px;}
             .project.marker { background-image:url(../images/project_marker.png); background-repeat: no-repeat; border: 0; margin-left: -4px; margin-top: 1px; }
             .version-behind-schedule a, .issue-behind-schedule a {color: #f66914;}
             .version-overdue a, .issue-overdue a, .project-overdue a {color: #f00;}
             /***** Icons *****/
             .icon {
               background-position: 0% 50%;
               background-repeat: no-repeat;
               padding-left: 20px;
               padding-top: 2px;
               padding-bottom: 3px;
             }
             .icon-add { background-image: url(../images/add.png); }
             .icon-edit { background-image: url(../images/edit.png); }
             .icon-copy { background-image: url(../images/copy.png); }
             .icon-duplicate { background-image: url(../images/duplicate.png); }
             .icon-del { background-image: url(../images/delete.png); }
             .icon-move { background-image: url(../images/move.png); }
             .icon-save { background-image: url(../images/save.png); }
             .icon-cancel { background-image: url(../images/cancel.png); }
             .icon-multiple { background-image: url(../images/table_multiple.png); }
             .icon-folder { background-image: url(../images/folder.png); }
             .open .icon-folder { background-image: url(../images/folder_open.png); }
             .icon-package { background-image: url(../images/package.png); }
             .icon-user { background-image: url(../images/user.png); }
             .icon-projects { background-image: url(../images/projects.png); }
             .icon-help { background-image: url(../images/help.png); }
             .icon-attachment  { background-image: url(../images/attachment.png); }
             .icon-history  { background-image: url(../images/history.png); }
             .icon-time  { background-image: url(../images/time.png); }
             .icon-time-add  { background-image: url(../images/time_add.png); }
             .icon-stats  { background-image: url(../images/stats.png); }
             .icon-warning  { background-image: url(../images/warning.png); }
             .icon-fav  { background-image: url(../images/fav.png); }
             .icon-fav-off  { background-image: url(../images/fav_off.png); }
             .icon-reload  { background-image: url(../images/reload.png); }
             .icon-lock  { background-image: url(../images/locked.png); }
             .icon-unlock  { background-image: url(../images/unlock.png); }
             .icon-checked  { background-image: url(../images/true.png); }
             .icon-details  { background-image: url(../images/zoom_in.png); }
             .icon-report  { background-image: url(../images/report.png); }
             .icon-comment  { background-image: url(../images/comment.png); }
             .icon-summary  { background-image: url(../images/lightning.png); }
             .icon-server-authentication { background-image: url(../images/server_key.png); }
             .icon-issue { background-image: url(../images/ticket.png); }
             .icon-zoom-in { background-image: url(../images/zoom_in.png); }
             .icon-zoom-out { background-image: url(../images/zoom_out.png); }
             .icon-passwd { background-image: url(../images/textfield_key.png); }
             .icon-test { background-image: url(../images/bullet_go.png); }
             .icon-file { background-image: url(../images/files/default.png); }
             .icon-file.text-plain { background-image: url(../images/files/text.png); }
             .icon-file.text-x-c { background-image: url(../images/files/c.png); }
             .icon-file.text-x-csharp { background-image: url(../images/files/csharp.png); }
             .icon-file.text-x-java { background-image: url(../images/files/java.png); }
             .icon-file.text-x-javascript { background-image: url(../images/files/js.png); }
             .icon-file.text-x-php { background-image: url(../images/files/php.png); }
             .icon-file.text-x-ruby { background-image: url(../images/files/ruby.png); }
             .icon-file.text-xml { background-image: url(../images/files/xml.png); }
             .icon-file.text-css { background-image: url(../images/files/css.png); }
             .icon-file.text-html { background-image: url(../images/files/html.png); }
             .icon-file.image-gif { background-image: url(../images/files/image.png); }
             .icon-file.image-jpeg { background-image: url(../images/files/image.png); }
             .icon-file.image-png { background-image: url(../images/files/image.png); }
             .icon-file.image-tiff { background-image: url(../images/files/image.png); }
             .icon-file.application-pdf { background-image: url(../images/files/pdf.png); }
             .icon-file.application-zip { background-image: url(../images/files/zip.png); }
             .icon-file.application-x-gzip { background-image: url(../images/files/zip.png); }
             img.gravatar {
               padding: 2px;
               border: solid 1px #d5d5d5;
               background: #fff;
               vertical-align: middle;
             }
             div.issue img.gravatar {
               float: left;
               margin: 0 6px 0 0;
               padding: 5px;
             }
             div.issue table img.gravatar {
               height: 14px;
               width: 14px;
               padding: 2px;
               float: left;
               margin: 0 0.5em 0 0;
             }
             h2 img.gravatar {margin: -2px 4px -4px 0;}
             h3 img.gravatar {margin: -4px 4px -4px 0;}
             h4 img.gravatar {margin: -6px 4px -4px 0;}
             td.username img.gravatar {margin: 0 0.5em 0 0; vertical-align: top;}
             #activity dt img.gravatar {float: left; margin: 0 1em 1em 0;}
             /* Used on 12px Gravatar img tags without the icon background */
             .icon-gravatar {float: left; margin-right: 4px;}
             #activity dt, .journal {clear: left;}
             .journal-link {float: right;}
             h2 img { vertical-align:middle; }
             .hascontextmenu { cursor: context-menu; }
             /************* CodeRay styles *************/
             .syntaxhl div {display: inline;}
             .syntaxhl .line-numbers {padding: 2px 4px 2px 4px; background-color: #eee; margin:0px 5px 0px 0px;}
             .syntaxhl .code pre { overflow: auto }
             .syntaxhl .debug { color: white !important; background: blue !important; }
             .syntaxhl .annotation { color:#007 }
             .syntaxhl .attribute-name { color:#b48 }
             .syntaxhl .attribute-value { color:#700 }
             .syntaxhl .binary { color:#509 }
             .syntaxhl .char .content { color:#D20 }
             .syntaxhl .char .delimiter { color:#710 }
             .syntaxhl .char { color:#D20 }
             .syntaxhl .class { color:#258; font-weight:bold }
             .syntaxhl .class-variable { color:#369 }
             .syntaxhl .color { color:#0A0 }
             .syntaxhl .comment { color:#385 }
             .syntaxhl .comment .char { color:#385 }
             .syntaxhl .comment .delimiter { color:#385 }
             .syntaxhl .complex { color:#A08 }
             .syntaxhl .constant { color:#258; font-weight:bold }
             .syntaxhl .decorator { color:#B0B }
             .syntaxhl .definition { color:#099; font-weight:bold }
             .syntaxhl .delimiter { color:black }
             .syntaxhl .directive { color:#088; font-weight:bold }
             .syntaxhl .doc { color:#970 }
             .syntaxhl .doc-string { color:#D42; font-weight:bold }
             .syntaxhl .doctype { color:#34b }
             .syntaxhl .entity { color:#800; font-weight:bold }
             .syntaxhl .error { color:#F00; background-color:#FAA }
             .syntaxhl .escape  { color:#666 }
             .syntaxhl .exception { color:#C00; font-weight:bold }
             .syntaxhl .float { color:#06D }
             .syntaxhl .function { color:#06B; font-weight:bold }
             .syntaxhl .global-variable { color:#d70 }
             .syntaxhl .hex { color:#02b }
             .syntaxhl .imaginary { color:#f00 }
             .syntaxhl .include { color:#B44; font-weight:bold }
             .syntaxhl .inline { background-color: hsla(0,0%,0%,0.07); color: black }
             .syntaxhl .inline-delimiter { font-weight: bold; color: #666 }
             .syntaxhl .instance-variable { color:#33B }
             .syntaxhl .integer  { color:#06D }
             .syntaxhl .key .char { color: #60f }
             .syntaxhl .key .delimiter { color: #404 }
             .syntaxhl .key { color: #606 }
             .syntaxhl .keyword { color:#939; font-weight:bold }
             .syntaxhl .label { color:#970; font-weight:bold }
             .syntaxhl .local-variable { color:#963 }
             .syntaxhl .namespace { color:#707; font-weight:bold }
             .syntaxhl .octal { color:#40E }
             .syntaxhl .operator { }
             .syntaxhl .predefined { color:#369; font-weight:bold }
             .syntaxhl .predefined-constant { color:#069 }
             .syntaxhl .predefined-type { color:#0a5; font-weight:bold }
             .syntaxhl .preprocessor { color:#579 }
             .syntaxhl .pseudo-class { color:#00C; font-weight:bold }
             .syntaxhl .regexp .content { color:#808 }
             .syntaxhl .regexp .delimiter { color:#404 }
             .syntaxhl .regexp .modifier { color:#C2C }
             .syntaxhl .regexp { background-color:hsla(300,100%,50%,0.06); }
             .syntaxhl .reserved { color:#080; font-weight:bold }
             .syntaxhl .shell .content { color:#2B2 }
             .syntaxhl .shell .delimiter { color:#161 }
             .syntaxhl .shell { background-color:hsla(120,100%,50%,0.06); }
             .syntaxhl .string .char { color: #46a }
             .syntaxhl .string .content { color: #46a }
             .syntaxhl .string .delimiter { color: #46a }
             .syntaxhl .string .modifier { color: #46a }
             .syntaxhl .symbol .content { color:#d33 }
             .syntaxhl .symbol .delimiter { color:#d33 }
             .syntaxhl .symbol { color:#d33 }
             .syntaxhl .tag { color:#070 }
             .syntaxhl .type { color:#339; font-weight:bold }
             .syntaxhl .value { color: #088; }
             .syntaxhl .variable  { color:#037 }
             .syntaxhl .insert { background: hsla(120,100%,50%,0.12) }
             .syntaxhl .delete { background: hsla(0,100%,50%,0.12) }
             .syntaxhl .change { color: #bbf; background: #007; }
             .syntaxhl .head { color: #f8f; background: #505 }
             .syntaxhl .head .filename { color: white; }
             .syntaxhl .delete .eyecatcher { background-color: hsla(0,100%,50%,0.2); border: 1px solid hsla(0,100%,45%,0.5); margin: -1px; border-bottom: none; border-top-left-radius: 5px; border-top-right-radius: 5px; }
             .syntaxhl .insert .eyecatcher { background-color: hsla(120,100%,50%,0.2); border: 1px solid hsla(120,100%,25%,0.5); margin: -1px; border-top: none; border-bottom-left-radius: 5px; border-bottom-right-radius: 5px; }
             .syntaxhl .insert .insert { color: #0c0; background:transparent; font-weight:bold }
             .syntaxhl .delete .delete { color: #c00; background:transparent; font-weight:bold }
             .syntaxhl .change .change { color: #88f }
             .syntaxhl .head .head { color: #f4f }
             /***** Media print specific styles *****/
             @media print {
               #top-menu, #header, #main-menu, #sidebar, #footer, .contextual, .other-formats { display:none; }
               #main { background: #fff; }
               #content { width: 99%; margin: 0; padding: 0; border: 0; background: #fff; overflow: visible !important;}
               #wiki_add_attachment { display:none; }
               .hide-when-print { display: none; }
               .autoscroll {overflow-x: visible;}
               table.list {margin-top:0.5em;}
               table.list th, table.list td {border: 1px solid #aaa;}
             }
             /* Accessibility specific styles */
             .hidden-for-sighted {
               position:absolute;
               left:-10000px;
               top:auto;
               width:1px;
               height:1px;
               overflow:hidden;
             }

test/test_helper.rb +9 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 'shoulda'
             ENV["RAILS_ENV"] = "test"
             require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
             require 'rails/test_help'
             require Rails.root.join('test', 'mocks', 'open_id_authentication_mock.rb').to_s
             require File.expand_path(File.dirname(__FILE__) + '/object_helpers')
             include ObjectHelpers
             class ActiveSupport::TestCase
               include ActionDispatch::TestProcess
               # Transactional fixtures accelerate your tests by wrapping each test method
               # in a transaction that's rolled back on completion.  This ensures that the
               # test database remains unchanged so your fixtures don't have to be reloaded
               # between every test method.  Fewer database queries means faster tests.
               #
               # Read Mike Clark's excellent walkthrough at
               #   http://clarkware.com/cgi/blosxom/2005/10/24#Rails10FastTesting
               #
               # Every Active Record database supports transactions except MyISAM tables
               # in MySQL.  Turn off transactional fixtures in this case; however, if you
               # don't care one way or the other, switching from MyISAM to InnoDB tables
               # is recommended.
               self.use_transactional_fixtures = true
               # Instantiated fixtures are slow, but give you @david where otherwise you
               # would need people(:david).  If you don't want to migrate your existing
               # test cases which use the @david style and don't mind the speed hit (each
               # instantiated fixtures translates to a database query per test method),
               # then set this back to true.
               self.use_instantiated_fixtures  = false
               # Add more helper methods to be used by all tests here...
               def log_user(login, password)
                 User.anonymous
                 get "/login"
                 assert_equal nil, session[:user_id]
                 assert_response :success
                 assert_template "account/login"
                 post "/login", :username => login, :password => password
                 assert_equal login, User.find(session[:user_id]).login
               end
               def uploaded_test_file(name, mime)
                 fixture_file_upload("files/#{name}", mime, true)
               end
               def credentials(user, password=nil)
                 {'HTTP_AUTHORIZATION' => ActionController::HttpAuthentication::Basic.encode_credentials(user, password || user)}
               end
               # Mock out a file
               def self.mock_file
                 file = 'a_file.png'
                 file.stubs(:size).returns(32)
                 file.stubs(:original_filename).returns('a_file.png')
                 file.stubs(:content_type).returns('image/png')
                 file.stubs(:read).returns(false)
                 file
               end
               def mock_file
                 self.class.mock_file
               end
               def mock_file_with_options(options={})
                 file = ''
                 file.stubs(:size).returns(32)
                 original_filename = options[:original_filename] || nil
                 file.stubs(:original_filename).returns(original_filename)
                 content_type = options[:content_type] || nil
                 file.stubs(:content_type).returns(content_type)
                 file.stubs(:read).returns(false)
                 file
               end
               # Use a temporary directory for attachment related tests
               def set_tmp_attachments_directory
                 Dir.mkdir "#{Rails.root}/tmp/test" unless File.directory?("#{Rails.root}/tmp/test")
                 unless File.directory?("#{Rails.root}/tmp/test/attachments")
                   Dir.mkdir "#{Rails.root}/tmp/test/attachments"
                 end
                 Attachment.storage_path = "#{Rails.root}/tmp/test/attachments"
               end
               def set_fixtures_attachments_directory
                 Attachment.storage_path = "#{Rails.root}/test/fixtures/files"
               end
               def with_settings(options, &block)
                 saved_settings = options.keys.inject({}) {|h, k| h[k] = Setting[k].is_a?(Symbol) ? Setting[k] : Setting[k].dup; h}
                 options.each {|k, v| Setting[k] = v}
                 yield
               ensure
                 saved_settings.each {|k, v| Setting[k] = v} if saved_settings
               end
+              # Yields the block with user as the current user
+              def with_current_user(user, &block)
+                saved_user = User.current
+                User.current = user
+                yield
+              ensure
+                User.current = saved_user
+              end
               def change_user_password(login, new_password)
                 user = User.first(:conditions => {:login => login})
                 user.password, user.password_confirmation = new_password, new_password
                 user.save!
               end
               def self.ldap_configured?
                 @test_ldap = Net::LDAP.new(:host => '127.0.0.1', :port => 389)
                 return @test_ldap.bind
               rescue Exception => e
                 # LDAP is not listening
                 return nil
               end
               def self.convert_installed?
                 Redmine::Thumbnail.convert_available?
               end
               # Returns the path to the test +vendor+ repository
               def self.repository_path(vendor)
                 Rails.root.join("tmp/test/#{vendor.downcase}_repository").to_s
               end
               # Returns the url of the subversion test repository
               def self.subversion_repository_url
                 path = repository_path('subversion')
                 path = '/' + path unless path.starts_with?('/')
                 "file://#{path}"
               end
               # Returns true if the +vendor+ test repository is configured
               def self.repository_configured?(vendor)
                 File.directory?(repository_path(vendor))
               end
               def repository_path_hash(arr)
                 hs = {}
                 hs[:path]  = arr.join("/")
                 hs[:param] = arr.join("/")
                 hs
               end
               def assert_save(object)
                 saved = object.save
                 message = "#{object.class} could not be saved"
                 errors = object.errors.full_messages.map {|m| "- #{m}"}
                 message << ":\n#{errors.join("\n")}" if errors.any?
                 assert_equal true, saved, message
               end
               def assert_error_tag(options={})
                 assert_tag({:attributes => { :id => 'errorExplanation' }}.merge(options))
               end
               def assert_include(expected, s, message=nil)
                 assert s.include?(expected), (message || "\"#{expected}\" not found in \"#{s}\"")
               end
               def assert_not_include(expected, s)
                 assert !s.include?(expected), "\"#{expected}\" found in \"#{s}\""
               end
               def assert_mail_body_match(expected, mail)
                 if expected.is_a?(String)
                   assert_include expected, mail_body(mail)
                 else
                   assert_match expected, mail_body(mail)
                 end
               end
               def assert_mail_body_no_match(expected, mail)
                 if expected.is_a?(String)
                   assert_not_include expected, mail_body(mail)
                 else
                   assert_no_match expected, mail_body(mail)
                 end
               end
               def mail_body(mail)
                 mail.parts.first.body.encoded
               end
               # Shoulda macros
               def self.should_render_404
                 should_respond_with :not_found
                 should_render_template 'common/error'
               end
               def self.should_have_before_filter(expected_method, options = {})
                 should_have_filter('before', expected_method, options)
               end
               def self.should_have_after_filter(expected_method, options = {})
                 should_have_filter('after', expected_method, options)
               end
               def self.should_have_filter(filter_type, expected_method, options)
                 description = "have #{filter_type}_filter :#{expected_method}"
                 description << " with #{options.inspect}" unless options.empty?
                 should description do
                   klass = "action_controller/filters/#{filter_type}_filter".classify.constantize
                   expected = klass.new(:filter, expected_method.to_sym, options)
                   assert_equal 1, @controller.class.filter_chain.select { |filter|
                     filter.method == expected.method && filter.kind == expected.kind &&
                     filter.options == expected.options && filter.class == expected.class
                   }.size
                 end
               end
               # Test that a request allows the three types of API authentication
               #
               # * HTTP Basic with username and password
               # * HTTP Basic with an api key for the username
               # * Key based with the key=X parameter
               #
               # @param [Symbol] http_method the HTTP method for request (:get, :post, :put, :delete)
               # @param [String] url the request url
               # @param [optional, Hash] parameters additional request parameters
               # @param [optional, Hash] options additional options
               # @option options [Symbol] :success_code Successful response code (:success)
               # @option options [Symbol] :failure_code Failure response code (:unauthorized)
               def self.should_allow_api_authentication(http_method, url, parameters={}, options={})
                 should_allow_http_basic_auth_with_username_and_password(http_method, url, parameters, options)
                 should_allow_http_basic_auth_with_key(http_method, url, parameters, options)
                 should_allow_key_based_auth(http_method, url, parameters, options)
               end
               # Test that a request allows the username and password for HTTP BASIC
               #
               # @param [Symbol] http_method the HTTP method for request (:get, :post, :put, :delete)
               # @param [String] url the request url
               # @param [optional, Hash] parameters additional request parameters
               # @param [optional, Hash] options additional options
               # @option options [Symbol] :success_code Successful response code (:success)
               # @option options [Symbol] :failure_code Failure response code (:unauthorized)
               def self.should_allow_http_basic_auth_with_username_and_password(http_method, url, parameters={}, options={})
                 success_code = options[:success_code] || :success
                 failure_code = options[:failure_code] || :unauthorized
                 context "should allow http basic auth using a username and password for #{http_method} #{url}" do
                   context "with a valid HTTP authentication" do
                     setup do
                       @user = User.generate! do |user|
                         user.admin = true
                         user.password = 'my_password'
                       end
                       send(http_method, url, parameters, credentials(@user.login, 'my_password'))
                     end
                     should_respond_with success_code
                     should_respond_with_content_type_based_on_url(url)
                     should "login as the user" do
                       assert_equal @user, User.current
                     end
                   end
                   context "with an invalid HTTP authentication" do
                     setup do
                       @user = User.generate!
                       send(http_method, url, parameters, credentials(@user.login, 'wrong_password'))
                     end
                     should_respond_with failure_code
                     should_respond_with_content_type_based_on_url(url)
                     should "not login as the user" do
                       assert_equal User.anonymous, User.current
                     end
                   end
                   context "without credentials" do
                     setup do
                       send(http_method, url, parameters)
                     end
                     should_respond_with failure_code
                     should_respond_with_content_type_based_on_url(url)
                     should "include_www_authenticate_header" do
                       assert @controller.response.headers.has_key?('WWW-Authenticate')
                     end
                   end
                 end
               end
               # Test that a request allows the API key with HTTP BASIC
               #
               # @param [Symbol] http_method the HTTP method for request (:get, :post, :put, :delete)
               # @param [String] url the request url
               # @param [optional, Hash] parameters additional request parameters
               # @param [optional, Hash] options additional options
               # @option options [Symbol] :success_code Successful response code (:success)
               # @option options [Symbol] :failure_code Failure response code (:unauthorized)
               def self.should_allow_http_basic_auth_with_key(http_method, url, parameters={}, options={})
                 success_code = options[:success_code] || :success
                 failure_code = options[:failure_code] || :unauthorized
                 context "should allow http basic auth with a key for #{http_method} #{url}" do
                   context "with a valid HTTP authentication using the API token" do
                     setup do
                       @user = User.generate! do |user|
                         user.admin = true
                       end
                       @token = Token.create!(:user => @user, :action => 'api')
                       send(http_method, url, parameters, credentials(@token.value, 'X'))
                     end
                     should_respond_with success_code
                     should_respond_with_content_type_based_on_url(url)
                     should_be_a_valid_response_string_based_on_url(url)
                     should "login as the user" do
                       assert_equal @user, User.current
                     end
                   end
                   context "with an invalid HTTP authentication" do
                     setup do
                       @user = User.generate!
                       @token = Token.create!(:user => @user, :action => 'feeds')
                       send(http_method, url, parameters, credentials(@token.value, 'X'))
                     end
                     should_respond_with failure_code
                     should_respond_with_content_type_based_on_url(url)
                     should "not login as the user" do
                       assert_equal User.anonymous, User.current
                     end
                   end
                 end
               end
               # Test that a request allows full key authentication
               #
               # @param [Symbol] http_method the HTTP method for request (:get, :post, :put, :delete)
               # @param [String] url the request url, without the key=ZXY parameter
               # @param [optional, Hash] parameters additional request parameters
               # @param [optional, Hash] options additional options
               # @option options [Symbol] :success_code Successful response code (:success)
               # @option options [Symbol] :failure_code Failure response code (:unauthorized)
               def self.should_allow_key_based_auth(http_method, url, parameters={}, options={})
                 success_code = options[:success_code] || :success
                 failure_code = options[:failure_code] || :unauthorized
                 context "should allow key based auth using key=X for #{http_method} #{url}" do
                   context "with a valid api token" do
                     setup do
                       @user = User.generate! do |user|
                         user.admin = true
                       end
                       @token = Token.create!(:user => @user, :action => 'api')
                       # Simple url parse to add on ?key= or &key=
                       request_url = if url.match(/\?/)
                                       url + "&key=#{@token.value}"
                                     else
                                       url + "?key=#{@token.value}"
                                     end
                       send(http_method, request_url, parameters)
                     end
                     should_respond_with success_code
                     should_respond_with_content_type_based_on_url(url)
                     should_be_a_valid_response_string_based_on_url(url)
                     should "login as the user" do
                       assert_equal @user, User.current
                     end
                   end
                   context "with an invalid api token" do
                     setup do
                       @user = User.generate! do |user|
                         user.admin = true
                       end
                       @token = Token.create!(:user => @user, :action => 'feeds')
                       # Simple url parse to add on ?key= or &key=
                       request_url = if url.match(/\?/)
                                       url + "&key=#{@token.value}"
                                     else
                                       url + "?key=#{@token.value}"
                                     end
                       send(http_method, request_url, parameters)
                     end
                     should_respond_with failure_code
                     should_respond_with_content_type_based_on_url(url)
                     should "not login as the user" do
                       assert_equal User.anonymous, User.current
                     end
                   end
                 end
                 context "should allow key based auth using X-Redmine-API-Key header for #{http_method} #{url}" do
                   setup do
                     @user = User.generate! do |user|
                       user.admin = true
                     end
                     @token = Token.create!(:user => @user, :action => 'api')
                     send(http_method, url, parameters, {'X-Redmine-API-Key' => @token.value.to_s})
                   end
                   should_respond_with success_code
                   should_respond_with_content_type_based_on_url(url)
                   should_be_a_valid_response_string_based_on_url(url)
                   should "login as the user" do
                     assert_equal @user, User.current
                   end
                 end
               end
               # Uses should_respond_with_content_type based on what's in the url:
               #
               # '/project/issues.xml' => should_respond_with_content_type :xml
               # '/project/issues.json' => should_respond_with_content_type :json
               #
               # @param [String] url Request
               def self.should_respond_with_content_type_based_on_url(url)
                 case
                 when url.match(/xml/i)
                   should "respond with XML" do
                     assert_equal 'application/xml', @response.content_type
                   end
                 when url.match(/json/i)
                   should "respond with JSON" do
                     assert_equal 'application/json', @response.content_type
                   end
                 else
                   raise "Unknown content type for should_respond_with_content_type_based_on_url: #{url}"
                 end
               end
               # Uses the url to assert which format the response should be in
               #
               # '/project/issues.xml' => should_be_a_valid_xml_string
               # '/project/issues.json' => should_be_a_valid_json_string
               #
               # @param [String] url Request
               def self.should_be_a_valid_response_string_based_on_url(url)
                 case
                 when url.match(/xml/i)
                   should_be_a_valid_xml_string
                 when url.match(/json/i)
                   should_be_a_valid_json_string
                 else
                   raise "Unknown content type for should_be_a_valid_response_based_on_url: #{url}"
                 end
               end
               # Checks that the response is a valid JSON string
               def self.should_be_a_valid_json_string
                 should "be a valid JSON string (or empty)" do
                   assert(response.body.blank? || ActiveSupport::JSON.decode(response.body))
                 end
               end
               # Checks that the response is a valid XML string
               def self.should_be_a_valid_xml_string
                 should "be a valid XML string" do
                   assert REXML::Document.new(response.body)
                 end
               end
               def self.should_respond_with(status)
                 should "respond with #{status}" do
                   assert_response status
                 end
               end
             end
             # Simple module to "namespace" all of the API tests
             module ApiTest
             end

test/unit/helpers/application_helper_test.rb +14 -6

             # 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 File.expand_path('../../../test_helper', __FILE__)
             class ApplicationHelperTest < ActionView::TestCase
               include ERB::Util
               fixtures :projects, :roles, :enabled_modules, :users,
                        :repositories, :changesets,
                        :trackers, :issue_statuses, :issues, :versions, :documents,
                        :wikis, :wiki_pages, :wiki_contents,
                        :boards, :messages, :news,
                        :attachments, :enumerations
               def setup
                 super
                 set_tmp_attachments_directory
               end
               context "#link_to_if_authorized" do
                 context "authorized user" do
                   should "be tested"
                 end
                 context "unauthorized user" do
                   should "be tested"
                 end
                 should "allow using the :controller and :action for the target link" do
                   User.current = User.find_by_login('admin')
                   @project = Issue.first.project # Used by helper
                   response = link_to_if_authorized("By controller/action",
                                                    {:controller => 'issues', :action => 'edit', :id => Issue.first.id})
                   assert_match /href/, response
                 end
               end
               def test_auto_links
                 to_test = {
                   'http://foo.bar' => '<a class="external" href="http://foo.bar">http://foo.bar</a>',
                   'http://foo.bar/~user' => '<a class="external" href="http://foo.bar/~user">http://foo.bar/~user</a>',
                   'http://foo.bar.' => '<a class="external" href="http://foo.bar">http://foo.bar</a>.',
                   'https://foo.bar.' => '<a class="external" href="https://foo.bar">https://foo.bar</a>.',
                   'This is a link: http://foo.bar.' => 'This is a link: <a class="external" href="http://foo.bar">http://foo.bar</a>.',
                   'A link (eg. http://foo.bar).' => 'A link (eg. <a class="external" href="http://foo.bar">http://foo.bar</a>).',
                   'http://foo.bar/foo.bar#foo.bar.' => '<a class="external" href="http://foo.bar/foo.bar#foo.bar">http://foo.bar/foo.bar#foo.bar</a>.',
                   'http://www.foo.bar/Test_(foobar)' => '<a class="external" href="http://www.foo.bar/Test_(foobar)">http://www.foo.bar/Test_(foobar)</a>',
                   '(see inline link : http://www.foo.bar/Test_(foobar))' => '(see inline link : <a class="external" href="http://www.foo.bar/Test_(foobar)">http://www.foo.bar/Test_(foobar)</a>)',
                   '(see inline link : http://www.foo.bar/Test)' => '(see inline link : <a class="external" href="http://www.foo.bar/Test">http://www.foo.bar/Test</a>)',
                   '(see inline link : http://www.foo.bar/Test).' => '(see inline link : <a class="external" href="http://www.foo.bar/Test">http://www.foo.bar/Test</a>).',
                   '(see "inline link":http://www.foo.bar/Test_(foobar))' => '(see <a href="http://www.foo.bar/Test_(foobar)" class="external">inline link</a>)',
                   '(see "inline link":http://www.foo.bar/Test)' => '(see <a href="http://www.foo.bar/Test" class="external">inline link</a>)',
                   '(see "inline link":http://www.foo.bar/Test).' => '(see <a href="http://www.foo.bar/Test" class="external">inline link</a>).',
                   'www.foo.bar' => '<a class="external" href="http://www.foo.bar">www.foo.bar</a>',
                   'http://foo.bar/page?p=1&t=z&s=' => '<a class="external" href="http://foo.bar/page?p=1&#38;t=z&#38;s=">http://foo.bar/page?p=1&#38;t=z&#38;s=</a>',
                   'http://foo.bar/page#125' => '<a class="external" href="http://foo.bar/page#125">http://foo.bar/page#125</a>',
                   'http://foo@www.bar.com' => '<a class="external" href="http://foo@www.bar.com">http://foo@www.bar.com</a>',
                   'http://foo:bar@www.bar.com' => '<a class="external" href="http://foo:bar@www.bar.com">http://foo:bar@www.bar.com</a>',
                   'ftp://foo.bar' => '<a class="external" href="ftp://foo.bar">ftp://foo.bar</a>',
                   'ftps://foo.bar' => '<a class="external" href="ftps://foo.bar">ftps://foo.bar</a>',
                   'sftp://foo.bar' => '<a class="external" href="sftp://foo.bar">sftp://foo.bar</a>',
                   # two exclamation marks
                   'http://example.net/path!602815048C7B5C20!302.html' => '<a class="external" href="http://example.net/path!602815048C7B5C20!302.html">http://example.net/path!602815048C7B5C20!302.html</a>',
                   # escaping
                   'http://foo"bar' => '<a class="external" href="http://foo&quot;bar">http://foo&quot;bar</a>',
                   # wrap in angle brackets
                   '<http://foo.bar>' => '&lt;<a class="external" href="http://foo.bar">http://foo.bar</a>&gt;'
                 }
                 to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text) }
               end
               def test_auto_mailto
                 assert_equal '<p><a class="email" href="mailto:test@foo.bar">test@foo.bar</a></p>',
                   textilizable('test@foo.bar')
               end
               def test_inline_images
                 to_test = {
                   '!http://foo.bar/image.jpg!' => '<img src="http://foo.bar/image.jpg" alt="" />',
                   'floating !>http://foo.bar/image.jpg!' => 'floating <div style="float:right"><img src="http://foo.bar/image.jpg" alt="" /></div>',
                   'with class !(some-class)http://foo.bar/image.jpg!' => 'with class <img src="http://foo.bar/image.jpg" class="some-class" alt="" />',
                   'with style !{width:100px;height:100px}http://foo.bar/image.jpg!' => 'with style <img src="http://foo.bar/image.jpg" style="width:100px;height:100px;" alt="" />',
                   'with title !http://foo.bar/image.jpg(This is a title)!' => 'with title <img src="http://foo.bar/image.jpg" title="This is a title" alt="This is a title" />',
                   'with title !http://foo.bar/image.jpg(This is a double-quoted "title")!' => 'with title <img src="http://foo.bar/image.jpg" title="This is a double-quoted &quot;title&quot;" alt="This is a double-quoted &quot;title&quot;" />',
                 }
                 to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text) }
               end
               def test_inline_images_inside_tags
                 raw = <<-RAW
             h1. !foo.png! Heading
             Centered image:
             p=. !bar.gif!
             RAW
                 assert textilizable(raw).include?('<img src="foo.png" alt="" />')
                 assert textilizable(raw).include?('<img src="bar.gif" alt="" />')
               end
               def test_attached_images
                 to_test = {
                   'Inline image: !logo.gif!' => 'Inline image: <img src="/attachments/download/3" title="This is a logo" alt="This is a logo" />',
                   'Inline image: !logo.GIF!' => 'Inline image: <img src="/attachments/download/3" title="This is a logo" alt="This is a logo" />',
                   'No match: !ogo.gif!' => 'No match: <img src="ogo.gif" alt="" />',
                   'No match: !ogo.GIF!' => 'No match: <img src="ogo.GIF" alt="" />',
                   # link image
                   '!logo.gif!:http://foo.bar/' => '<a href="http://foo.bar/"><img src="/attachments/download/3" title="This is a logo" alt="This is a logo" /></a>',
                 }
                 attachments = Attachment.find(:all)
                 to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text, :attachments => attachments) }
               end
               def test_attached_images_filename_extension
                 set_tmp_attachments_directory
                 a1 = Attachment.new(
                         :container => Issue.find(1),
                         :file => mock_file_with_options({:original_filename => "testtest.JPG"}),
                         :author => User.find(1))
                 assert a1.save
                 assert_equal "testtest.JPG", a1.filename
                 assert_equal "image/jpeg", a1.content_type
                 assert a1.image?
                 a2 = Attachment.new(
                         :container => Issue.find(1),
                         :file => mock_file_with_options({:original_filename => "testtest.jpeg"}),
                         :author => User.find(1))
                 assert a2.save
                 assert_equal "testtest.jpeg", a2.filename
                 assert_equal "image/jpeg", a2.content_type
                 assert a2.image?
                 a3 = Attachment.new(
                         :container => Issue.find(1),
                         :file => mock_file_with_options({:original_filename => "testtest.JPE"}),
                         :author => User.find(1))
                 assert a3.save
                 assert_equal "testtest.JPE", a3.filename
                 assert_equal "image/jpeg", a3.content_type
                 assert a3.image?
                 a4 = Attachment.new(
                         :container => Issue.find(1),
                         :file => mock_file_with_options({:original_filename => "Testtest.BMP"}),
                         :author => User.find(1))
                 assert a4.save
                 assert_equal "Testtest.BMP", a4.filename
                 assert_equal "image/x-ms-bmp", a4.content_type
                 assert a4.image?
                 to_test = {
                   'Inline image: !testtest.jpg!' =>
                     'Inline image: <img src="/attachments/download/' + a1.id.to_s + '" alt="" />',
                   'Inline image: !testtest.jpeg!' =>
                     'Inline image: <img src="/attachments/download/' + a2.id.to_s + '" alt="" />',
                   'Inline image: !testtest.jpe!' =>
                     'Inline image: <img src="/attachments/download/' + a3.id.to_s + '" alt="" />',
                   'Inline image: !testtest.bmp!' =>
                     'Inline image: <img src="/attachments/download/' + a4.id.to_s + '" alt="" />',
                 }
                 attachments = [a1, a2, a3, a4]
                 to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text, :attachments => attachments) }
               end
               def test_attached_images_should_read_later
                 set_fixtures_attachments_directory
                 a1 = Attachment.find(16)
                 assert_equal "testfile.png", a1.filename
                 assert a1.readable?
                 assert (! a1.visible?(User.anonymous))
                 assert a1.visible?(User.find(2))
                 a2 = Attachment.find(17)
                 assert_equal "testfile.PNG", a2.filename
                 assert a2.readable?
                 assert (! a2.visible?(User.anonymous))
                 assert a2.visible?(User.find(2))
                 assert a1.created_on < a2.created_on
                 to_test = {
                   'Inline image: !testfile.png!' =>
                     'Inline image: <img src="/attachments/download/' + a2.id.to_s + '" alt="" />',
                   'Inline image: !Testfile.PNG!' =>
                     'Inline image: <img src="/attachments/download/' + a2.id.to_s + '" alt="" />',
                 }
                 attachments = [a1, a2]
                 to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text, :attachments => attachments) }
                 set_tmp_attachments_directory
               end
               def test_textile_external_links
                 to_test = {
                   'This is a "link":http://foo.bar' => 'This is a <a href="http://foo.bar" class="external">link</a>',
                   'This is an intern "link":/foo/bar' => 'This is an intern <a href="/foo/bar">link</a>',
                   '"link (Link title)":http://foo.bar' => '<a href="http://foo.bar" title="Link title" class="external">link</a>',
                   '"link (Link title with "double-quotes")":http://foo.bar' => '<a href="http://foo.bar" title="Link title with &quot;double-quotes&quot;" class="external">link</a>',
                   "This is not a \"Link\":\n\nAnother paragraph" => "This is not a \"Link\":</p>\n\n\n\t<p>Another paragraph",
                   # no multiline link text
                   "This is a double quote \"on the first line\nand another on a second line\":test" => "This is a double quote \"on the first line<br />and another on a second line\":test",
                   # mailto link
                   "\"system administrator\":mailto:sysadmin@example.com?subject=redmine%20permissions" => "<a href=\"mailto:sysadmin@example.com?subject=redmine%20permissions\">system administrator</a>",
                   # two exclamation marks
                   '"a link":http://example.net/path!602815048C7B5C20!302.html' => '<a href="http://example.net/path!602815048C7B5C20!302.html" class="external">a link</a>',
                   # escaping
                   '"test":http://foo"bar' => '<a href="http://foo&quot;bar" class="external">test</a>',
                 }
                 to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text) }
               end
               def test_redmine_links
                 issue_link = link_to('#3', {:controller => 'issues', :action => 'show', :id => 3},
                                            :class => 'issue status-1 priority-4 overdue', :title => 'Error 281 when updating a recipe (New)')
                 note_link = link_to('#3', {:controller => 'issues', :action => 'show', :id => 3, :anchor => 'note-14'},
                                            :class => 'issue status-1 priority-4 overdue', :title => 'Error 281 when updating a recipe (New)')
                 changeset_link = link_to('r1', {:controller => 'repositories', :action => 'revision', :id => 'ecookbook', :rev => 1},
                                                :class => 'changeset', :title => 'My very first commit')
                 changeset_link2 = link_to('r2', {:controller => 'repositories', :action => 'revision', :id => 'ecookbook', :rev => 2},
                                                 :class => 'changeset', :title => 'This commit fixes #1, #2 and references #1 & #3')
                 document_link = link_to('Test document', {:controller => 'documents', :action => 'show', :id => 1},
                                                          :class => 'document')
                 version_link = link_to('1.0', {:controller => 'versions', :action => 'show', :id => 2},
                                               :class => 'version')
                 board_url = {:controller => 'boards', :action => 'show', :id => 2, :project_id => 'ecookbook'}
                 message_url = {:controller => 'messages', :action => 'show', :board_id => 1, :id => 4}
                 news_url = {:controller => 'news', :action => 'show', :id => 1}
                 project_url = {:controller => 'projects', :action => 'show', :id => 'subproject1'}
                 source_url = '/projects/ecookbook/repository/entry/some/file'
                 source_url_with_rev = '/projects/ecookbook/repository/revisions/52/entry/some/file'
                 source_url_with_ext = '/projects/ecookbook/repository/entry/some/file.ext'
                 source_url_with_rev_and_ext = '/projects/ecookbook/repository/revisions/52/entry/some/file.ext'
                 export_url = '/projects/ecookbook/repository/raw/some/file'
                 export_url_with_rev = '/projects/ecookbook/repository/revisions/52/raw/some/file'
                 export_url_with_ext = '/projects/ecookbook/repository/raw/some/file.ext'
                 export_url_with_rev_and_ext = '/projects/ecookbook/repository/revisions/52/raw/some/file.ext'
                 to_test = {
                   # tickets
                   '#3, [#3], (#3) and #3.'      => "#{issue_link}, [#{issue_link}], (#{issue_link}) and #{issue_link}.",
                   # ticket notes
                   '#3-14'                       => note_link,
                   '#3#note-14'                  => note_link,
                   # should not ignore leading zero
                   '#03'                         => '#03',
                   # changesets
                   'r1'                          => changeset_link,
                   'r1.'                         => "#{changeset_link}.",
                   'r1, r2'                      => "#{changeset_link}, #{changeset_link2}",
                   'r1,r2'                       => "#{changeset_link},#{changeset_link2}",
                   # documents
                   'document#1'                  => document_link,
                   'document:"Test document"'    => document_link,
                   # versions
                   'version#2'                   => version_link,
                   'version:1.0'                 => version_link,
                   'version:"1.0"'               => version_link,
                   # source
                   'source:some/file'            => link_to('source:some/file', source_url, :class => 'source'),
                   'source:/some/file'           => link_to('source:/some/file', source_url, :class => 'source'),
                   'source:/some/file.'          => link_to('source:/some/file', source_url, :class => 'source') + ".",
                   'source:/some/file.ext.'      => link_to('source:/some/file.ext', source_url_with_ext, :class => 'source') + ".",
                   'source:/some/file. '         => link_to('source:/some/file', source_url, :class => 'source') + ".",
                   'source:/some/file.ext. '     => link_to('source:/some/file.ext', source_url_with_ext, :class => 'source') + ".",
                   'source:/some/file, '         => link_to('source:/some/file', source_url, :class => 'source') + ",",
                   'source:/some/file@52'        => link_to('source:/some/file@52', source_url_with_rev, :class => 'source'),
                   'source:/some/file.ext@52'    => link_to('source:/some/file.ext@52', source_url_with_rev_and_ext, :class => 'source'),
                   'source:/some/file#L110'      => link_to('source:/some/file#L110', source_url + "#L110", :class => 'source'),
                   'source:/some/file.ext#L110'  => link_to('source:/some/file.ext#L110', source_url_with_ext + "#L110", :class => 'source'),
                   'source:/some/file@52#L110'   => link_to('source:/some/file@52#L110', source_url_with_rev + "#L110", :class => 'source'),
                   # export
                   'export:/some/file'           => link_to('export:/some/file', export_url, :class => 'source download'),
                   'export:/some/file.ext'       => link_to('export:/some/file.ext', export_url_with_ext, :class => 'source download'),
                   'export:/some/file@52'        => link_to('export:/some/file@52', export_url_with_rev, :class => 'source download'),
                   'export:/some/file.ext@52'    => link_to('export:/some/file.ext@52', export_url_with_rev_and_ext, :class => 'source download'),
                   # forum
                   'forum#2'                     => link_to('Discussion', board_url, :class => 'board'),
                   'forum:Discussion'            => link_to('Discussion', board_url, :class => 'board'),
                   # message
                   'message#4'                   => link_to('Post 2', message_url, :class => 'message'),
                   'message#5'                   => link_to('RE: post 2', message_url.merge(:anchor => 'message-5', :r => 5), :class => 'message'),
                   # news
                   'news#1'                      => link_to('eCookbook first release !', news_url, :class => 'news'),
                   'news:"eCookbook first release !"'        => link_to('eCookbook first release !', news_url, :class => 'news'),
                   # project
                   'project#3'                   => link_to('eCookbook Subproject 1', project_url, :class => 'project'),
                   'project:subproject1'         => link_to('eCookbook Subproject 1', project_url, :class => 'project'),
                   'project:"eCookbook subProject 1"'        => link_to('eCookbook Subproject 1', project_url, :class => 'project'),
                   # not found
                   '#0123456789'                 => '#0123456789',
                   # invalid expressions
                   'source:'                     => 'source:',
                   # url hash
                   "http://foo.bar/FAQ#3"       => '<a class="external" href="http://foo.bar/FAQ#3">http://foo.bar/FAQ#3</a>',
                 }
                 @project = Project.find(1)
                 to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text), "#{text} failed" }
               end
               def test_escaped_redmine_links_should_not_be_parsed
                 to_test = [
                   '#3.',
                   '#3-14.',
                   '#3#-note14.',
                   'r1',
                   'document#1',
                   'document:"Test document"',
                   'version#2',
                   'version:1.0',
                   'version:"1.0"',
                   'source:/some/file'
                 ]
                 @project = Project.find(1)
                 to_test.each { |text| assert_equal "<p>#{text}</p>", textilizable("!" + text), "#{text} failed" }
               end
               def test_cross_project_redmine_links
                 source_link = link_to('ecookbook:source:/some/file', {:controller => 'repositories', :action => 'entry', :id => 'ecookbook', :path => ['some', 'file']},
                   :class => 'source')
                 changeset_link = link_to('ecookbook:r2', {:controller => 'repositories', :action => 'revision', :id => 'ecookbook', :rev => 2},
                   :class => 'changeset', :title => 'This commit fixes #1, #2 and references #1 & #3')
                 to_test = {
                   # documents
                   'document:"Test document"'              => 'document:"Test document"',
                   'ecookbook:document:"Test document"'    => '<a href="/documents/1" class="document">Test document</a>',
                   'invalid:document:"Test document"'      => 'invalid:document:"Test document"',
                   # versions
                   'version:"1.0"'                         => 'version:"1.0"',
                   'ecookbook:version:"1.0"'               => '<a href="/versions/2" class="version">1.0</a>',
                   'invalid:version:"1.0"'                 => 'invalid:version:"1.0"',
                   # changeset
                   'r2'                                    => 'r2',
                   'ecookbook:r2'                          => changeset_link,
                   'invalid:r2'                            => 'invalid:r2',
                   # source
                   'source:/some/file'                     => 'source:/some/file',
                   'ecookbook:source:/some/file'           => source_link,
                   'invalid:source:/some/file'             => 'invalid:source:/some/file',
                 }
                 @project = Project.find(3)
                 to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text), "#{text} failed" }
               end
               def test_multiple_repositories_redmine_links
                 svn = Repository::Subversion.create!(:project_id => 1, :identifier => 'svn1', :url => 'file:///foo/hg')
                 Changeset.create!(:repository => svn, :committed_on => Time.now, :revision => '123')
                 hg = Repository::Mercurial.create!(:project_id => 1, :identifier => 'hg1', :url => '/foo/hg')
                 Changeset.create!(:repository => hg, :committed_on => Time.now, :revision => '123', :scmid => 'abcd')
                 changeset_link = link_to('r2', {:controller => 'repositories', :action => 'revision', :id => 'ecookbook', :rev => 2},
                                                 :class => 'changeset', :title => 'This commit fixes #1, #2 and references #1 & #3')
                 svn_changeset_link = link_to('svn1|r123', {:controller => 'repositories', :action => 'revision', :id => 'ecookbook', :repository_id => 'svn1', :rev => 123},
                                                 :class => 'changeset', :title => '')
                 hg_changeset_link = link_to('hg1|abcd', {:controller => 'repositories', :action => 'revision', :id => 'ecookbook', :repository_id => 'hg1', :rev => 'abcd'},
                                                 :class => 'changeset', :title => '')
                 source_link = link_to('source:some/file', {:controller => 'repositories', :action => 'entry', :id => 'ecookbook', :path => ['some', 'file']}, :class => 'source')
                 hg_source_link = link_to('source:hg1|some/file', {:controller => 'repositories', :action => 'entry', :id => 'ecookbook', :repository_id => 'hg1', :path => ['some', 'file']}, :class => 'source')
                 to_test = {
                   'r2'                          => changeset_link,
                   'svn1|r123'                   => svn_changeset_link,
                   'invalid|r123'                => 'invalid|r123',
                   'commit:hg1|abcd'             => hg_changeset_link,
                   'commit:invalid|abcd'         => 'commit:invalid|abcd',
                   # source
                   'source:some/file'            => source_link,
                   'source:hg1|some/file'        => hg_source_link,
                   'source:invalid|some/file'    => 'source:invalid|some/file',
                 }
                 @project = Project.find(1)
                 to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text), "#{text} failed" }
               end
               def test_cross_project_multiple_repositories_redmine_links
                 svn = Repository::Subversion.create!(:project_id => 1, :identifier => 'svn1', :url => 'file:///foo/hg')
                 Changeset.create!(:repository => svn, :committed_on => Time.now, :revision => '123')
                 hg = Repository::Mercurial.create!(:project_id => 1, :identifier => 'hg1', :url => '/foo/hg')
                 Changeset.create!(:repository => hg, :committed_on => Time.now, :revision => '123', :scmid => 'abcd')
                 changeset_link = link_to('ecookbook:r2', {:controller => 'repositories', :action => 'revision', :id => 'ecookbook', :rev => 2},
                                                 :class => 'changeset', :title => 'This commit fixes #1, #2 and references #1 & #3')
                 svn_changeset_link = link_to('ecookbook:svn1|r123', {:controller => 'repositories', :action => 'revision', :id => 'ecookbook', :repository_id => 'svn1', :rev => 123},
                                                 :class => 'changeset', :title => '')
                 hg_changeset_link = link_to('ecookbook:hg1|abcd', {:controller => 'repositories', :action => 'revision', :id => 'ecookbook', :repository_id => 'hg1', :rev => 'abcd'},
                                                 :class => 'changeset', :title => '')
                 source_link = link_to('ecookbook:source:some/file', {:controller => 'repositories', :action => 'entry', :id => 'ecookbook', :path => ['some', 'file']}, :class => 'source')
                 hg_source_link = link_to('ecookbook:source:hg1|some/file', {:controller => 'repositories', :action => 'entry', :id => 'ecookbook', :repository_id => 'hg1', :path => ['some', 'file']}, :class => 'source')
                 to_test = {
                   'ecookbook:r2'                           => changeset_link,
                   'ecookbook:svn1|r123'                    => svn_changeset_link,
                   'ecookbook:invalid|r123'                 => 'ecookbook:invalid|r123',
                   'ecookbook:commit:hg1|abcd'              => hg_changeset_link,
                   'ecookbook:commit:invalid|abcd'          => 'ecookbook:commit:invalid|abcd',
                   'invalid:commit:invalid|abcd'            => 'invalid:commit:invalid|abcd',
                   # source
                   'ecookbook:source:some/file'             => source_link,
                   'ecookbook:source:hg1|some/file'         => hg_source_link,
                   'ecookbook:source:invalid|some/file'     => 'ecookbook:source:invalid|some/file',
                   'invalid:source:invalid|some/file'       => 'invalid:source:invalid|some/file',
                 }
                 @project = Project.find(3)
                 to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text), "#{text} failed" }
               end
               def test_redmine_links_git_commit
                 changeset_link = link_to('abcd',
                                            {
                                              :controller => 'repositories',
                                              :action     => 'revision',
                                              :id         => 'subproject1',
                                              :rev        => 'abcd',
                                             },
                                           :class => 'changeset', :title => 'test commit')
                 to_test = {
                   'commit:abcd' => changeset_link,
                  }
                 @project = Project.find(3)
                 r = Repository::Git.create!(:project => @project, :url => '/tmp/test/git')
                 assert r
                 c = Changeset.new(:repository => r,
                                   :committed_on => Time.now,
                                   :revision => 'abcd',
                                   :scmid => 'abcd',
                                   :comments => 'test commit')
                 assert( c.save )
                 to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text) }
               end
               # TODO: Bazaar commit id contains mail address, so it contains '@' and '_'.
               def test_redmine_links_darcs_commit
                 changeset_link = link_to('20080308225258-98289-abcd456efg.gz',
                                            {
                                              :controller => 'repositories',
                                              :action     => 'revision',
                                              :id         => 'subproject1',
                                              :rev        => '123',
                                             },
                                           :class => 'changeset', :title => 'test commit')
                 to_test = {
                   'commit:20080308225258-98289-abcd456efg.gz' => changeset_link,
                  }
                 @project = Project.find(3)
                 r = Repository::Darcs.create!(
                         :project => @project, :url => '/tmp/test/darcs',
                         :log_encoding => 'UTF-8')
                 assert r
                 c = Changeset.new(:repository => r,
                                   :committed_on => Time.now,
                                   :revision => '123',
                                   :scmid => '20080308225258-98289-abcd456efg.gz',
                                   :comments => 'test commit')
                 assert( c.save )
                 to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text) }
               end
               def test_redmine_links_mercurial_commit
                 changeset_link_rev = link_to('r123',
                                               {
                                                  :controller => 'repositories',
                                                  :action     => 'revision',
                                                  :id         => 'subproject1',
                                                  :rev        => '123' ,
                                               },
                                           :class => 'changeset', :title => 'test commit')
                 changeset_link_commit = link_to('abcd',
                                               {
                                                     :controller => 'repositories',
                                                     :action     => 'revision',
                                                     :id         => 'subproject1',
                                                     :rev        => 'abcd' ,
                                               },
                                           :class => 'changeset', :title => 'test commit')
                 to_test = {
                   'r123' => changeset_link_rev,
                   'commit:abcd' => changeset_link_commit,
                  }
                 @project = Project.find(3)
                 r = Repository::Mercurial.create!(:project => @project, :url => '/tmp/test')
                 assert r
                 c = Changeset.new(:repository => r,
                                   :committed_on => Time.now,
                                   :revision => '123',
                                   :scmid => 'abcd',
                                   :comments => 'test commit')
                 assert( c.save )
                 to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text) }
               end
               def test_attachment_links
                 attachment_link = link_to('error281.txt', {:controller => 'attachments', :action => 'download', :id => '1'}, :class => 'attachment')
                 to_test = {
                   'attachment:error281.txt'      => attachment_link
                 }
                 to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text, :attachments => Issue.find(3).attachments), "#{text} failed" }
               end
               def test_wiki_links
                 to_test = {
                   '[[CookBook documentation]]' => '<a href="/projects/ecookbook/wiki/CookBook_documentation" class="wiki-page">CookBook documentation</a>',
                   '[[Another page|Page]]' => '<a href="/projects/ecookbook/wiki/Another_page" class="wiki-page">Page</a>',
                   # title content should be formatted
                   '[[Another page|With _styled_ *title*]]' => '<a href="/projects/ecookbook/wiki/Another_page" class="wiki-page">With <em>styled</em> <strong>title</strong></a>',
                   '[[Another page|With title containing <strong>HTML entities &amp; markups</strong>]]' => '<a href="/projects/ecookbook/wiki/Another_page" class="wiki-page">With title containing &lt;strong&gt;HTML entities &amp; markups&lt;/strong&gt;</a>',
                   # link with anchor
                   '[[CookBook documentation#One-section]]' => '<a href="/projects/ecookbook/wiki/CookBook_documentation#One-section" class="wiki-page">CookBook documentation</a>',
                   '[[Another page#anchor|Page]]' => '<a href="/projects/ecookbook/wiki/Another_page#anchor" class="wiki-page">Page</a>',
                   # UTF8 anchor
                   '[[Another_page#Тест|Тест]]' => %|<a href="/projects/ecookbook/wiki/Another_page##{CGI.escape 'Тест'}" class="wiki-page">Тест</a>|,
                   # page that doesn't exist
                   '[[Unknown page]]' => '<a href="/projects/ecookbook/wiki/Unknown_page" class="wiki-page new">Unknown page</a>',
                   '[[Unknown page|404]]' => '<a href="/projects/ecookbook/wiki/Unknown_page" class="wiki-page new">404</a>',
                   # link to another project wiki
                   '[[onlinestore:]]' => '<a href="/projects/onlinestore/wiki" class="wiki-page">onlinestore</a>',
                   '[[onlinestore:|Wiki]]' => '<a href="/projects/onlinestore/wiki" class="wiki-page">Wiki</a>',
                   '[[onlinestore:Start page]]' => '<a href="/projects/onlinestore/wiki/Start_page" class="wiki-page">Start page</a>',
                   '[[onlinestore:Start page|Text]]' => '<a href="/projects/onlinestore/wiki/Start_page" class="wiki-page">Text</a>',
                   '[[onlinestore:Unknown page]]' => '<a href="/projects/onlinestore/wiki/Unknown_page" class="wiki-page new">Unknown page</a>',
                   # striked through link
                   '-[[Another page|Page]]-' => '<del><a href="/projects/ecookbook/wiki/Another_page" class="wiki-page">Page</a></del>',
                   '-[[Another page|Page]] link-' => '<del><a href="/projects/ecookbook/wiki/Another_page" class="wiki-page">Page</a> link</del>',
                   # escaping
                   '![[Another page|Page]]' => '[[Another page|Page]]',
                   # project does not exist
                   '[[unknowproject:Start]]' => '[[unknowproject:Start]]',
                   '[[unknowproject:Start|Page title]]' => '[[unknowproject:Start|Page title]]',
                 }
                 @project = Project.find(1)
                 to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text) }
               end
               def test_wiki_links_within_local_file_generation_context
                 to_test = {
                   # link to a page
                   '[[CookBook documentation]]' => '<a href="CookBook_documentation.html" class="wiki-page">CookBook documentation</a>',
                   '[[CookBook documentation|documentation]]' => '<a href="CookBook_documentation.html" class="wiki-page">documentation</a>',
                   '[[CookBook documentation#One-section]]' => '<a href="CookBook_documentation.html#One-section" class="wiki-page">CookBook documentation</a>',
                   '[[CookBook documentation#One-section|documentation]]' => '<a href="CookBook_documentation.html#One-section" class="wiki-page">documentation</a>',
                   # page that doesn't exist
                   '[[Unknown page]]' => '<a href="Unknown_page.html" class="wiki-page new">Unknown page</a>',
                   '[[Unknown page|404]]' => '<a href="Unknown_page.html" class="wiki-page new">404</a>',
                   '[[Unknown page#anchor]]' => '<a href="Unknown_page.html#anchor" class="wiki-page new">Unknown page</a>',
                   '[[Unknown page#anchor|404]]' => '<a href="Unknown_page.html#anchor" class="wiki-page new">404</a>',
                 }
                 @project = Project.find(1)
                 to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text, :wiki_links => :local) }
               end
               def test_wiki_links_within_wiki_page_context
                 page = WikiPage.find_by_title('Another_page' )
                 to_test = {
                   # link to another page
                   '[[CookBook documentation]]' => '<a href="/projects/ecookbook/wiki/CookBook_documentation" class="wiki-page">CookBook documentation</a>',
                   '[[CookBook documentation|documentation]]' => '<a href="/projects/ecookbook/wiki/CookBook_documentation" class="wiki-page">documentation</a>',
                   '[[CookBook documentation#One-section]]' => '<a href="/projects/ecookbook/wiki/CookBook_documentation#One-section" class="wiki-page">CookBook documentation</a>',
                   '[[CookBook documentation#One-section|documentation]]' => '<a href="/projects/ecookbook/wiki/CookBook_documentation#One-section" class="wiki-page">documentation</a>',
                   # link to the current page
                   '[[Another page]]' => '<a href="/projects/ecookbook/wiki/Another_page" class="wiki-page">Another page</a>',
                   '[[Another page|Page]]' => '<a href="/projects/ecookbook/wiki/Another_page" class="wiki-page">Page</a>',
                   '[[Another page#anchor]]' => '<a href="#anchor" class="wiki-page">Another page</a>',
                   '[[Another page#anchor|Page]]' => '<a href="#anchor" class="wiki-page">Page</a>',
                   # page that doesn't exist
                   '[[Unknown page]]' => '<a href="/projects/ecookbook/wiki/Unknown_page?parent=Another_page" class="wiki-page new">Unknown page</a>',
                   '[[Unknown page|404]]' => '<a href="/projects/ecookbook/wiki/Unknown_page?parent=Another_page" class="wiki-page new">404</a>',
                   '[[Unknown page#anchor]]' => '<a href="/projects/ecookbook/wiki/Unknown_page?parent=Another_page#anchor" class="wiki-page new">Unknown page</a>',
                   '[[Unknown page#anchor|404]]' => '<a href="/projects/ecookbook/wiki/Unknown_page?parent=Another_page#anchor" class="wiki-page new">404</a>',
                 }
                 @project = Project.find(1)
                 to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(WikiContent.new( :text => text, :page => page ), :text) }
               end
               def test_wiki_links_anchor_option_should_prepend_page_title_to_href
                 to_test = {
                   # link to a page
                   '[[CookBook documentation]]' => '<a href="#CookBook_documentation" class="wiki-page">CookBook documentation</a>',
                   '[[CookBook documentation|documentation]]' => '<a href="#CookBook_documentation" class="wiki-page">documentation</a>',
                   '[[CookBook documentation#One-section]]' => '<a href="#CookBook_documentation_One-section" class="wiki-page">CookBook documentation</a>',
                   '[[CookBook documentation#One-section|documentation]]' => '<a href="#CookBook_documentation_One-section" class="wiki-page">documentation</a>',
                   # page that doesn't exist
                   '[[Unknown page]]' => '<a href="#Unknown_page" class="wiki-page new">Unknown page</a>',
                   '[[Unknown page|404]]' => '<a href="#Unknown_page" class="wiki-page new">404</a>',
                   '[[Unknown page#anchor]]' => '<a href="#Unknown_page_anchor" class="wiki-page new">Unknown page</a>',
                   '[[Unknown page#anchor|404]]' => '<a href="#Unknown_page_anchor" class="wiki-page new">404</a>',
                 }
                 @project = Project.find(1)
                 to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text, :wiki_links => :anchor) }
               end
               def test_html_tags
                 to_test = {
                   "<div>content</div>" => "<p>&lt;div&gt;content&lt;/div&gt;</p>",
                   "<div class=\"bold\">content</div>" => "<p>&lt;div class=\"bold\"&gt;content&lt;/div&gt;</p>",
                   "<script>some script;</script>" => "<p>&lt;script&gt;some script;&lt;/script&gt;</p>",
                   # do not escape pre/code tags
                   "<pre>\nline 1\nline2</pre>" => "<pre>\nline 1\nline2</pre>",
                   "<pre><code>\nline 1\nline2</code></pre>" => "<pre><code>\nline 1\nline2</code></pre>",
                   "<pre><div>content</div></pre>" => "<pre>&lt;div&gt;content&lt;/div&gt;</pre>",
                   "HTML comment: <!-- no comments -->" => "<p>HTML comment: &lt;!-- no comments --&gt;</p>",
                   "<!-- opening comment" => "<p>&lt;!-- opening comment</p>",
                   # remove attributes except class
                   "<pre class='foo'>some text</pre>" => "<pre class='foo'>some text</pre>",
                   '<pre class="foo">some text</pre>' => '<pre class="foo">some text</pre>',
                   "<pre class='foo bar'>some text</pre>" => "<pre class='foo bar'>some text</pre>",
                   '<pre class="foo bar">some text</pre>' => '<pre class="foo bar">some text</pre>',
                   "<pre onmouseover='alert(1)'>some text</pre>" => "<pre>some text</pre>",
                   # xss
                   '<pre><code class=""onmouseover="alert(1)">text</code></pre>' => '<pre><code>text</code></pre>',
                   '<pre class=""onmouseover="alert(1)">text</pre>' => '<pre>text</pre>',
                 }
                 to_test.each { |text, result| assert_equal result, textilizable(text) }
               end
               def test_allowed_html_tags
                 to_test = {
                   "<pre>preformatted text</pre>" => "<pre>preformatted text</pre>",
                   "<notextile>no *textile* formatting</notextile>" => "no *textile* formatting",
                   "<notextile>this is <tag>a tag</tag></notextile>" => "this is &lt;tag&gt;a tag&lt;/tag&gt;"
                 }
                 to_test.each { |text, result| assert_equal result, textilizable(text) }
               end
               def test_pre_tags
                 raw = <<-RAW
             Before
             <pre>
             <prepared-statement-cache-size>32</prepared-statement-cache-size>
             </pre>
             After
             RAW
                 expected = <<-EXPECTED
             <p>Before</p>
             <pre>
             &lt;prepared-statement-cache-size&gt;32&lt;/prepared-statement-cache-size&gt;
             </pre>
             <p>After</p>
             EXPECTED
                 assert_equal expected.gsub(%r{[\r\n\t]}, ''), textilizable(raw).gsub(%r{[\r\n\t]}, '')
               end
               def test_pre_content_should_not_parse_wiki_and_redmine_links
                 raw = <<-RAW
             [[CookBook documentation]]
             #1
             <pre>
             [[CookBook documentation]]
             #1
             </pre>
             RAW
                 expected = <<-EXPECTED
             <p><a href="/projects/ecookbook/wiki/CookBook_documentation" class="wiki-page">CookBook documentation</a></p>
             <p><a href="/issues/1" class="issue status-1 priority-4" title="Can&#x27;t print recipes (New)">#1</a></p>
             <pre>
             [[CookBook documentation]]
             #1
             </pre>
             EXPECTED
                 @project = Project.find(1)
                 assert_equal expected.gsub(%r{[\r\n\t]}, ''), textilizable(raw).gsub(%r{[\r\n\t]}, '')
               end
               def test_non_closing_pre_blocks_should_be_closed
                 raw = <<-RAW
             <pre><code>
             RAW
                 expected = <<-EXPECTED
             <pre><code>
             </code></pre>
             EXPECTED
                 @project = Project.find(1)
                 assert_equal expected.gsub(%r{[\r\n\t]}, ''), textilizable(raw).gsub(%r{[\r\n\t]}, '')
               end
               def test_syntax_highlight
                 raw = <<-RAW
             <pre><code class="ruby">
             # Some ruby code here
             </code></pre>
             RAW
                 expected = <<-EXPECTED
             <pre><code class="ruby syntaxhl"><span class=\"CodeRay\"><span class="comment"># Some ruby code here</span></span>
             </code></pre>
             EXPECTED
                 assert_equal expected.gsub(%r{[\r\n\t]}, ''), textilizable(raw).gsub(%r{[\r\n\t]}, '')
               end
               def test_to_path_param
                 assert_equal 'test1/test2', to_path_param('test1/test2')
                 assert_equal 'test1/test2', to_path_param('/test1/test2/')
                 assert_equal 'test1/test2', to_path_param('//test1/test2/')
                 assert_equal nil, to_path_param('/')
               end
               def test_wiki_links_in_tables
                 to_test = {"|[[Page|Link title]]|[[Other Page|Other title]]|\n|Cell 21|[[Last page]]|" =>
                              '<tr><td><a href="/projects/ecookbook/wiki/Page" class="wiki-page new">Link title</a></td>' +
                              '<td><a href="/projects/ecookbook/wiki/Other_Page" class="wiki-page new">Other title</a></td>' +
                              '</tr><tr><td>Cell 21</td><td><a href="/projects/ecookbook/wiki/Last_page" class="wiki-page new">Last page</a></td></tr>'
                 }
                 @project = Project.find(1)
                 to_test.each { |text, result| assert_equal "<table>#{result}</table>", textilizable(text).gsub(/[\t\n]/, '') }
               end
               def test_text_formatting
                 to_test = {'*_+bold, italic and underline+_*' => '<strong><em><ins>bold, italic and underline</ins></em></strong>',
                            '(_text within parentheses_)' => '(<em>text within parentheses</em>)',
                            'a *Humane Web* Text Generator' => 'a <strong>Humane Web</strong> Text Generator',
                            'a H *umane* W *eb* T *ext* G *enerator*' => 'a H <strong>umane</strong> W <strong>eb</strong> T <strong>ext</strong> G <strong>enerator</strong>',
                            'a *H* umane *W* eb *T* ext *G* enerator' => 'a <strong>H</strong> umane <strong>W</strong> eb <strong>T</strong> ext <strong>G</strong> enerator',
                           }
                 to_test.each { |text, result| assert_equal "<p>#{result}</p>", textilizable(text) }
               end
               def test_wiki_horizontal_rule
                 assert_equal '<hr />', textilizable('---')
                 assert_equal '<p>Dashes: ---</p>', textilizable('Dashes: ---')
               end
               def test_footnotes
                 raw = <<-RAW
             This is some text[1].
             fn1. This is the foot note
             RAW
                 expected = <<-EXPECTED
             <p>This is some text<sup><a href=\"#fn1\">1</a></sup>.</p>
             <p id="fn1" class="footnote"><sup>1</sup> This is the foot note</p>
             EXPECTED
                 assert_equal expected.gsub(%r{[\r\n\t]}, ''), textilizable(raw).gsub(%r{[\r\n\t]}, '')
               end
               def test_headings
                 raw = 'h1. Some heading'
                 expected = %|<a name="Some-heading"></a>\n<h1 >Some heading<a href="#Some-heading" class="wiki-anchor">&para;</a></h1>|
                 assert_equal expected, textilizable(raw)
               end
               def test_headings_with_special_chars
                 # This test makes sure that the generated anchor names match the expected
                 # ones even if the heading text contains unconventional characters
                 raw = 'h1. Some heading related to version 0.5'
                 anchor = sanitize_anchor_name("Some-heading-related-to-version-0.5")
                 expected = %|<a name="#{anchor}"></a>\n<h1 >Some heading related to version 0.5<a href="##{anchor}" class="wiki-anchor">&para;</a></h1>|
                 assert_equal expected, textilizable(raw)
               end
               def test_headings_in_wiki_single_page_export_should_be_prepended_with_page_title
                 page = WikiPage.new( :title => 'Page Title', :wiki_id => 1 )
                 content = WikiContent.new( :text => 'h1. Some heading', :page => page )
                 expected = %|<a name="Page_Title_Some-heading"></a>\n<h1 >Some heading<a href="#Page_Title_Some-heading" class="wiki-anchor">&para;</a></h1>|
                 assert_equal expected, textilizable(content, :text, :wiki_links => :anchor )
               end
               def test_table_of_content
                 raw = <<-RAW
             {{toc}}
             h1. Title
             Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Maecenas sed libero.
             h2. Subtitle with a [[Wiki]] link
             Nullam commodo metus accumsan nulla. Curabitur lobortis dui id dolor.
             h2. Subtitle with [[Wiki|another Wiki]] link
             h2. Subtitle with %{color:red}red text%
             <pre>
             some code
             </pre>
             h3. Subtitle with *some* _modifiers_
             h3. Subtitle with @inline code@
             h1. Another title
             h3. An "Internet link":http://www.redmine.org/ inside subtitle
             h2. "Project Name !/attachments/1234/logo_small.gif! !/attachments/5678/logo_2.png!":/projects/projectname/issues
             RAW
                 expected =  '<ul class="toc">' +
                               '<li><a href="#Title">Title</a>' +
                                 '<ul>' +
                                   '<li><a href="#Subtitle-with-a-Wiki-link">Subtitle with a Wiki link</a></li>' +
                                   '<li><a href="#Subtitle-with-another-Wiki-link">Subtitle with another Wiki link</a></li>' +
                                   '<li><a href="#Subtitle-with-red-text">Subtitle with red text</a>' +
                                     '<ul>' +
                                       '<li><a href="#Subtitle-with-some-modifiers">Subtitle with some modifiers</a></li>' +
                                       '<li><a href="#Subtitle-with-inline-code">Subtitle with inline code</a></li>' +
                                     '</ul>' +
                                   '</li>' +
                                 '</ul>' +
                               '</li>' +
                               '<li><a href="#Another-title">Another title</a>' +
                                 '<ul>' +
                                   '<li>' +
                                     '<ul>' +
                                       '<li><a href="#An-Internet-link-inside-subtitle">An Internet link inside subtitle</a></li>' +
                                     '</ul>' +
                                   '</li>' +
                                   '<li><a href="#Project-Name">Project Name</a></li>' +
                                 '</ul>' +
                               '</li>' +
                            '</ul>'
                 @project = Project.find(1)
                 assert textilizable(raw).gsub("\n", "").include?(expected)
               end
               def test_table_of_content_should_generate_unique_anchors
                 raw = <<-RAW
             {{toc}}
             h1. Title
             h2. Subtitle
             h2. Subtitle
             RAW
                 expected =  '<ul class="toc">' +
                               '<li><a href="#Title">Title</a>' +
                                 '<ul>' +
                                   '<li><a href="#Subtitle">Subtitle</a></li>' +
                                   '<li><a href="#Subtitle-2">Subtitle</a></li>'
                                 '</ul>'
                               '</li>' +
                            '</ul>'
                 @project = Project.find(1)
                 result = textilizable(raw).gsub("\n", "")
                 assert_include expected, result
                 assert_include '<a name="Subtitle">', result
                 assert_include '<a name="Subtitle-2">', result
               end
               def test_table_of_content_should_contain_included_page_headings
                 raw = <<-RAW
             {{toc}}
             h1. Included
             {{include(Child_1)}}
             RAW
                 expected = '<ul class="toc">' +
                            '<li><a href="#Included">Included</a></li>' +
                            '<li><a href="#Child-page-1">Child page 1</a></li>' +
                            '</ul>'
                 @project = Project.find(1)
                 assert textilizable(raw).gsub("\n", "").include?(expected)
               end
               def test_section_edit_links
                 raw = <<-RAW
             h1. Title
             Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Maecenas sed libero.
             h2. Subtitle with a [[Wiki]] link
             h2. Subtitle with *some* _modifiers_
             h2. Subtitle with @inline code@
             <pre>
             some code
             h2. heading inside pre
             <h2>html heading inside pre</h2>
             </pre>
             h2. Subtitle after pre tag
             RAW
                 @project = Project.find(1)
                 set_language_if_valid 'en'
                 result = textilizable(raw, :edit_section_links => {:controller => 'wiki', :action => 'edit', :project_id => '1', :id => 'Test'}).gsub("\n", "")
                 # heading that contains inline code
                 assert_match Regexp.new('<div class="contextual" title="Edit this section">' +
                   '<a href="/projects/1/wiki/Test/edit\?section=4"><img alt="Edit" src="/images/edit.png(\?\d+)?" /></a></div>' +
                   '<a name="Subtitle-with-inline-code"></a>' +
                   '<h2 >Subtitle with <code>inline code</code><a href="#Subtitle-with-inline-code" class="wiki-anchor">&para;</a></h2>'),
                   result
                 # last heading
                 assert_match Regexp.new('<div class="contextual" title="Edit this section">' +
                   '<a href="/projects/1/wiki/Test/edit\?section=5"><img alt="Edit" src="/images/edit.png(\?\d+)?" /></a></div>' +
                   '<a name="Subtitle-after-pre-tag"></a>' +
                   '<h2 >Subtitle after pre tag<a href="#Subtitle-after-pre-tag" class="wiki-anchor">&para;</a></h2>'),
                   result
               end
               def test_default_formatter
                 with_settings :text_formatting => 'unknown' do
                   text = 'a *link*: http://www.example.net/'
                   assert_equal '<p>a *link*: <a class="external" href="http://www.example.net/">http://www.example.net/</a></p>', textilizable(text)
                 end
               end
               def test_due_date_distance_in_words
                 to_test = { Date.today => 'Due in 0 days',
                             Date.today + 1 => 'Due in 1 day',
                             Date.today + 100 => 'Due in about 3 months',
                             Date.today + 20000 => 'Due in over 54 years',
                             Date.today - 1 => '1 day late',
                             Date.today - 100 => 'about 3 months late',
                             Date.today - 20000 => 'over 54 years late',
                            }
                 ::I18n.locale = :en
                 to_test.each do |date, expected|
                   assert_equal expected, due_date_distance_in_words(date)
                 end
               end
               def test_avatar_enabled
                 with_settings :gravatar_enabled => '1' do
                   assert avatar(User.find_by_mail('jsmith@somenet.foo')).include?(Digest::MD5.hexdigest('jsmith@somenet.foo'))
                   assert avatar('jsmith <jsmith@somenet.foo>').include?(Digest::MD5.hexdigest('jsmith@somenet.foo'))
                   # Default size is 50
                   assert avatar('jsmith <jsmith@somenet.foo>').include?('size=50')
                   assert avatar('jsmith <jsmith@somenet.foo>', :size => 24).include?('size=24')
                   # Non-avatar options should be considered html options
                   assert avatar('jsmith <jsmith@somenet.foo>', :title => 'John Smith').include?('title="John Smith"')
                   # The default class of the img tag should be gravatar
                   assert avatar('jsmith <jsmith@somenet.foo>').include?('class="gravatar"')
                   assert !avatar('jsmith <jsmith@somenet.foo>', :class => 'picture').include?('class="gravatar"')
                   assert_nil avatar('jsmith')
                   assert_nil avatar(nil)
                 end
               end
               def test_avatar_disabled
                 with_settings :gravatar_enabled => '0' do
                   assert_equal '', avatar(User.find_by_mail('jsmith@somenet.foo'))
                 end
               end
               def test_link_to_user
                 user = User.find(2)
-                t = link_to_user(user)
+                assert_equal '<a href="/users/2" class="user active">John Smith</a>', link_to_user(user)
-                assert_equal "<a href=\"/users/2\">#{ user.name }</a>", t
               end
               def test_link_to_user_should_not_link_to_locked_user
-                user = User.find(5)
+                with_current_user nil do
-                assert user.locked?
+                  user = User.find(5)
-                t = link_to_user(user)
+                  assert user.locked?
-                assert_equal user.name, t
+                  assert_equal 'Dave2 Lopper2', link_to_user(user)
+                end
+              end
+              def test_link_to_user_should_link_to_locked_user_if_current_user_is_admin
+                with_current_user User.find(1) do
+                  user = User.find(5)
+                  assert user.locked?
+                  assert_equal '<a href="/users/5" class="user locked">Dave2 Lopper2</a>', link_to_user(user)
+                end
               end
               def test_link_to_user_should_not_link_to_anonymous
                 user = User.anonymous
                 assert user.anonymous?
                 t = link_to_user(user)
                 assert_equal ::I18n.t(:label_user_anonymous), t
               end
               def test_link_to_project
                 project = Project.find(1)
                 assert_equal %(<a href="/projects/ecookbook">eCookbook</a>),
                              link_to_project(project)
                 assert_equal %(<a href="/projects/ecookbook/settings">eCookbook</a>),
                              link_to_project(project, :action => 'settings')
                 assert_equal %(<a href="http://test.host/projects/ecookbook?jump=blah">eCookbook</a>),
                              link_to_project(project, {:only_path => false, :jump => 'blah'})
                 assert_equal %(<a href="/projects/ecookbook/settings" class="project">eCookbook</a>),
                              link_to_project(project, {:action => 'settings'}, :class => "project")
               end
               def test_link_to_legacy_project_with_numerical_identifier_should_use_id
                 # numeric identifier are no longer allowed
                 Project.update_all "identifier=25", "id=1"
                 assert_equal '<a href="/projects/1">eCookbook</a>',
                              link_to_project(Project.find(1))
               end
               def test_principals_options_for_select_with_users
                 User.current = nil
                 users = [User.find(2), User.find(4)]
                 assert_equal %(<option value="2">John Smith</option><option value="4">Robert Hill</option>),
                   principals_options_for_select(users)
               end
               def test_principals_options_for_select_with_selected
                 User.current = nil
                 users = [User.find(2), User.find(4)]
                 assert_equal %(<option value="2">John Smith</option><option value="4" selected="selected">Robert Hill</option>),
                   principals_options_for_select(users, User.find(4))
               end
               def test_principals_options_for_select_with_users_and_groups
                 User.current = nil
                 users = [User.find(2), Group.find(11), User.find(4), Group.find(10)]
                 assert_equal %(<option value="2">John Smith</option><option value="4">Robert Hill</option>) +
                   %(<optgroup label="Groups"><option value="10">A Team</option><option value="11">B Team</option></optgroup>),
                   principals_options_for_select(users)
               end
               def test_principals_options_for_select_with_empty_collection
                 assert_equal '', principals_options_for_select([])
               end
               def test_principals_options_for_select_should_include_me_option_when_current_user_is_in_collection
                 users = [User.find(2), User.find(4)]
                 User.current = User.find(4)
                 assert_include '<option value="4">&lt;&lt; me &gt;&gt;</option>', principals_options_for_select(users)
               end
               def test_stylesheet_link_tag_should_pick_the_default_stylesheet
                 assert_match 'href="/stylesheets/styles.css"', stylesheet_link_tag("styles")
               end
               def test_stylesheet_link_tag_for_plugin_should_pick_the_plugin_stylesheet
                 assert_match 'href="/plugin_assets/foo/stylesheets/styles.css"', stylesheet_link_tag("styles", :plugin => :foo)
               end
               def test_image_tag_should_pick_the_default_image
                 assert_match 'src="/images/image.png"', image_tag("image.png")
               end
               def test_image_tag_should_pick_the_theme_image_if_it_exists
                 theme = Redmine::Themes.themes.last
                 theme.images << 'image.png'
                 with_settings :ui_theme => theme.id do
                   assert_match %|src="/themes/#{theme.dir}/images/image.png"|, image_tag("image.png")
                   assert_match %|src="/images/other.png"|, image_tag("other.png")
                 end
               ensure
                 theme.images.delete 'image.png'
               end
               def test_image_tag_sfor_plugin_should_pick_the_plugin_image
                 assert_match 'src="/plugin_assets/foo/images/image.png"', image_tag("image.png", :plugin => :foo)
               end
               def test_javascript_include_tag_should_pick_the_default_javascript
                 assert_match 'src="/javascripts/scripts.js"', javascript_include_tag("scripts")
               end
               def test_javascript_include_tag_for_plugin_should_pick_the_plugin_javascript
                 assert_match 'src="/plugin_assets/foo/javascripts/scripts.js"', javascript_include_tag("scripts", :plugin => :foo)
               end
               def test_per_page_links_should_show_usefull_values
                 set_language_if_valid 'en'
                 stubs(:link_to).returns("[link]")
                 with_settings :per_page_options => '10, 25, 50, 100' do
                   assert_nil per_page_links(10, 3)
                   assert_nil per_page_links(25, 3)
                   assert_equal "Per page: 10, [link]", per_page_links(10, 22)
                   assert_equal "Per page: [link], 25", per_page_links(25, 22)
                   assert_equal "Per page: [link], [link], 50", per_page_links(50, 22)
                   assert_equal "Per page: [link], 25, [link]", per_page_links(25, 26)
                   assert_equal "Per page: [link], 25, [link], [link]", per_page_links(25, 120)
                 end
               end
             end

General Comments 0

Write
Preview

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

No TODOs yet

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

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